JAVA反射机制详解

反射机制有什么用

可以操作字节码文件

反射机制的相关类再哪个包下？

java.lang.reflect.*;

反射机制相关的类

java.lang.Class   代表字节码文件

java.lang.reflect.Method   代表字节码中的方法的字节码

java.lang.reflect.Constructor   代表字节码中的构造器的字节码

java.lang.reflect.Field   代表字节码中的属性的字节码

利用反射机制操作字节码文件

获取类的字节码

第一种方式：使用静态方法Class.forName(完整类名加包名)

Class c1 = Class.forName("java.lang.String");

Class.forName("java.lang.String");会导致类加载，即执行一次，String方法中的静态代码块也会执行一次，如果想一个类的静态方法执行一次，那么可以使用Class.forName()

第二种方式：使用Object类中的引用.getClass()方法

String s = "abc";
Class c = s.getClass();

第三种方式：java中的任意数据类型（包括基本数据类型）都有class属性

Class c = String.class;
Class c = int.class;

通过字节码文件来实例化对象

public class Test {
    public static void main(String[] args) {
        Class c = null;
        try {
            //通过反射机制获取字节码文件
            c = Class.forName("User");
            //newInstacnce()方法会调用User的无参构造方法来new一个User对象
            //必须保证User的无参构造方法存在！
            Object o = c.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

    }
}
class User{

}

注意：使用这种方法来初始化对象，更灵活！

举个例子

配置文件

//classinfo.Properties
className=com.sdut.wwg.User

User类

package com.sdut.wwg;

public class User {
    @Override
    public String toString() {
        return "User{}";
    }
}

Test类

import java.io.FileReader;
import java.util.Properties;

public class Test {
    public static void main(String[] args) throws Exception{
            //还可以这样获取绝对路径
            /*
            String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.Properities").getPath();
            
            还可以直接返回一个流
            InputStream r =Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream("classinfo.Properities");
            */
            FileReader r = new FileReader("Demo/src/classinfo.Properities");
            Properties p = new Properties();
            p.load(r);
            r.close();
            String className = p.getProperty("className");
            //通过反射机制获取字节码文件
            Class c= Class.forName(className);
            //newInstacnce()方法会调用User的无参构造方法来new一个User对象
            //必须保证User的无参构造方法存在！
            Object o = c.newInstance();
            System.out.println(o);


    }
}

这样的优点在于当服务器运行的时候，可以直接修改配置文件，而不需要改代码情况下可以做到不同对象的实例化

反射属性

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;


public class Test {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.sdut.wwg.User");
        //获取完整类名
        System.out.println("完整类名为"+c.getName());
        System.out.println("简类名为"+c.getSimpleName());
        //获取User所有的公共属性
        Field[] fs = c.getFields();
        System.out.println("所有声明公有属性数量总计"+fs.length);

        //获取User所有的属性
        Field[] allFs = c.getDeclaredFields();
        System.out.println("所有声明属性数量总计"+allFs.length);
        System.out.println("属性名为：");
        for (int i = 0; i <allFs.length ; i++) {
            System.out.println(allFs[i].getName());
        }
        System.out.println("各属性类型为:");
        for (int i = 0; i <allFs.length ; i++) {
            //获取属性修饰符
            int s = allFs[i].getModifiers();
            System.out.println(s);
            //可以将这个代号数字转换为字符串
            String modifierString = Modifier.toString(s);
            System.out.println(modifierString);
            //获取属性的类型
            Class fieldType = allFs[i].getType();
            System.out.println(fieldType.getSimpleName());
        }
    }
}

通过反射机制来反编译一个类的属性（了解）

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;


public class Test {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("User");
        StringBuffer s= new StringBuffer();
        //获取类的修饰符列表和类名
        s.append(Modifier.toString(c.getModifiers())+" class "+c.getSimpleName()+"{\n");
        Field[] fields = c.getDeclaredFields();
        for(Field f:fields){
            s.append("\t"); 
            s.append(Modifier.toString(f.getModifiers())+" ");
            s.append(f.getType().getSimpleName()+" ");
            s.append(f.getName()+";\n");
        }
        s.append("}");
        System.out.println(s);
    }
}

输出结果为

通过访问机制来访问一个java对象的属性

import java.lang.reflect.Field;


public class Test {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("User");
        Object o = c.newInstance();
        //获取no属性
        Field noField = c.getDeclaredField("no");
        //给o对象的no属性赋值
        noField.set(o,1111);
        //读取属性的值
        System.out.println(noField.get(o));

        //可以访问私有属性吗？？
        Field nameField = c.getDeclaredField("name");

        //需要打破封装.这样设置完之后，在外部也是可以访问私有属性的
        nameField.setAccessible(true);
        nameField.set(o,"jack");

        System.out.println(nameField.get(o));
    }
}

反射方法

public class Test {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("User");
        //获取所有的方法
        Method[] methods = c.getDeclaredMethods();
        //获取获取到的方法数量
        System.out.println(methods.length);
        for(Method m:methods){
            //输出方法的修饰符列表
            System.out.print(Modifier.toString(m.getModifiers())+" ");
            //输出方法的返回值类型
            System.out.print(m.getReturnType().getSimpleName()+" ");
            //输出方法的名字
            System.out.println(m.getName());
            //获取参数
            Class [] ctypes = m.getParameterTypes();
            for(Class clas: ctypes){
                //输出参数的类型
                System.out.println(clas.getSimpleName());
            }
        }
    }
}

反编译方法名和参数列表

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception{

        StringBuffer s = new StringBuffer();
        Class c = Class.forName("java.lang.String");
        Method [] methods = c.getDeclaredMethods();
        for(Method m: methods){
            s.append('\t');
            s.append(Modifier.toString(m.getModifiers())+" "+m.getReturnType().getSimpleName()+" "+m.getName());
            s.append(" (");
            Class []classes = m.getParameterTypes();
            for(Class cls : classes){
                s.append(cls.getSimpleName()+',');
            }
            if(classes.length>0)
            s.deleteCharAt(s.length()-1);
            s.append(") { }\n");
        }
        System.out.println(s);
    }
}

输出结果为

 

通过反射机制调用方法

 

import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) throws Exception{
        Class userClass = Class.forName("User");
        //创建一个User类对象
        Object o = userClass.newInstance();
        //获取sum方法
        Method sum = userClass.getDeclaredMethod("sum", int.class, int.class);

        //调用sum方法
        int result =(int)sum.invoke(o,1,2);
        System.out.println(result);
    }
}

通过反射机制调用有参构造方法

import java.lang.reflect.Constructor;

public class Test {
    public static void main(String[] args) throws Exception{
        Class userClass = Class.forName("User");
        //调用无参构造方法创建对象
        Object o = userClass.newInstance();
        //调用有参构造方法创建对象
        Constructor constructor = userClass.getConstructor(int.class,String.class);
        Object o1 = constructor.newInstance(1111,"jack");

        System.out.println(o);
        System.out.println(o1);
    }
}

输出结果为

通过反射机制获取父类以及实现了什么接口

public class Test {
    public static void main(String[] args) throws Exception{
        Class stringClass = Class.forName("java.lang.String");
        //获取父类名
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getSimpleName());
        //获取实现了什么接口
        Class[] interfaces = stringClass.getInterfaces();
        for(Class i:interfaces){
            System.out.println(i.getSimpleName());
        }
    }
}

输出结果