反射的概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

获取Class对象的三种方式

第一种方式：

通过调用java.lang.Class类下的静态方法：static Class forName(String className)
注意：

1. 参数是一个带有包名的完整类名(同目录下的可以只写类名)。
2. 抛出编译时异常：ClassNotFountException。
3. 该方法会导致相应的类被类加载。

代码如下：

public class MyClass {
    static{
        System.out.println(\"静态代码块执行！\");
    }
}
class Test{
	Class c = Class.forName(\"MyClass\");
}

编译结果：

第二种方式：

Object类下有个方法: public final Class getClass() ----- 返回此对象的Class。

代码如下：

Date d = new Date();
Class c2 = d.getClass();

第三种方式：

Java种任何一种类型，包括基本数据类型，都有class静态属性，直接通过 类名.class,就可以返回相应的Class类。

代码如下：

Class c = Date.class;

通过反射机制获取类的属性

相关方法：

• public Field[] getFields() ------- java.lang.Class中的方法，将类中public修饰的属性以数组的形式返回

• public Field[] getDeclaredFields() ------ java.lang.Class中的方法，将类中所有的属性以数组的形式返回

• public Class getType() ------ java.lang.reflect.Field中的方法，获取属性的类型并返回

• public int getModifiers() ----- java.lang.reflect.Field中的方法，获取属性的修饰符，并以整数编码的形式返回(一个整数编码可能代表多个修饰符)

• static String toString(int mod) ------ java.lang.reflect.Modifier中的静态方法，传入修饰符的整数编码，以字符串的形式将修饰符返回

代码如下：

public class ReflectTest05 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName(\"java.lang.String\");
        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\" + Modifier.toString(f.getModifiers()) + \" \"+ f.getType().getName()+ \" \" +f.getName()+\"\\n\");
        }
        s.append(\"}\");
        System.out.println(s);
    }
}

编译结果如下：

通过反射机制访问Java对象的属性

创建一个User类，如下：

public class User {
    //四个Field对象，分别采用四种不同的访问权限修饰符
    public int no;
    private String name;
    protected  int age;
    boolean sex;
}

代码如下：

public class ReflectTest06 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName(\"User\");
        //通过反射实例化User类
        Object user = c.newInstance();
        //设置User对象的no
        Field field = c.getDeclaredField(\"no\");
        field.set(user,12);
        //获得User对象的no
        System.out.println(field.get(user));

        //设置User对象的name，需要打破封装，因为name属性是私有属性，不能直接设置
        Field field1 = c.getDeclaredField(\"name\");
        field1.setAccessible(true);
        field1.set(user,\"Joke\");
        System.out.println(field1.get(user));
    }
}

反射机制与属性配置文件的配合使用

资源绑定器

java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。

代码如下：

public class ResourceBundleTest01 {
    public static void main(String[] args) {
        //资源绑定器，只能绑定xxx.properties文件，并且这个文件必须在类路径下，文件扩展名也必须是properties
        //并且在写路径时，路径后面的扩展名不能写
        ResourceBundle bundle = ResourceBundle.getBundle(\"classinfo\");
        String className = bundle.getString(\"className\");
        System.out.println(className);
    }
}

配合使用样例

首先我们创建一个属性配置文件，如下：

className = User
fieldName = name
fieldValue = zhangsan

样例代码如下：

public class ReflectTest07 {
    public static void main(String[] args) throws Exception{
        //配合属性文件使用
        ResourceBundle bundle = ResourceBundle.getBundle(\"classinfo\");
        Class c2 = Class.forName(bundle.getString(\"className\"));
        //通过反射实例化User类
        Object obj = c2.newInstance();
        Field field1 = c2.getDeclaredField(bundle.getString(\"fieldName\"));
        //打破封装
        field1.setAccessible(true);
        field1.set(obj,bundle.getString(\"fieldValue\"));
        System.out.println(field1.get(obj));
    }
}

通过反射机制获取类中方法

代码如下：

public class ReflectTest08 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName(\"java.lang.String\");
        Method[] methods = c.getDeclaredMethods();
        StringBuffer s = new StringBuffer();
        for(Method m:methods){
            Class[] parameterTypes = m.getParameterTypes();
            s.append(Modifier.toString(m.getModifiers()) + \" \" + m.getReturnType().getSimpleName() + \" \" + m.getName() + \"(\");
            for(Class cs:parameterTypes){
                s.append(cs.getSimpleName() + \" \");
            }
            s.append(\"){}\\n\");
        }
        System.out.println(s);
    }
}

编译结果：

通过反射机制调用Java对象的方法

使用反射机制调用一个对象的方法,步骤如下：

1. 获取对应类的Class对象。
2. 通过反射机制实例化出一个对象。
3. 通过方法 ：public Method getDeclaredMethod(String name, Class... parameterTypes)，获取对应的Method对象
   注意：getDeclaredMethod方法是在java.lang.Class下的方法，第一个参数是方法名，第二个参数是可变长参数，是该方法的形式参数类型列表
4. 通过方法：public Object invoke(Object obj,Object... args)，可以调用Method对象对应的方法。
   注意：该方法是java.lang.reflect.Method下的方法，第一个参数是对象，第二个参数是方法的实际参数列表。

往User类中添加方法，如下：

public class User {
    //四个Field对象，分别采用四种不同的访问权限修饰符
    public int no;
    private String name;
    protected  int age;
    boolean sex;
    public int doSome(int i){
        System.out.println(\"User对象中的doSome方法执行！\");
        return i;
    }
}

代码如下：

public class ReflectTest09 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName(\"User\");
        Object obj = c.newInstance();
        Method method = c.getDeclaredMethod(\"doSome\",int.class);
        System.out.println(method.invoke(obj,1));
    }
}

编译结果如下：

通过反射机制获取类中的构造方法

public class ReflectTest10 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName(\"java.lang.String\");
        Constructor[] constructors = c.getDeclaredConstructors();
        StringBuffer s = new StringBuffer();
        for(Constructor co: constructors){
            s.append(Modifier.toString(co.getModifiers()) + \" \" +c.getSimpleName() + \"(\");
            Class[] parameterType = co.getParameterTypes();
            for(Class cs:parameterType){
                s.append(cs.getSimpleName()+\" \");
            }
            s.append(\"){}\\n\");
        }
        System.out.println(s);
    }
}

编译结果如下：

通过反射机制创建对象(调用构造方法)

代码如下：

public class ReflectTest11 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName(\"User\");
        //默认调用无参数构造方法
        Object obj1 = c.newInstance();
        //因为每一个构造方法的方法名都一样，所以getDeclaredConstructor方法的参数只有要调用的构造方法的构造参数类型列表
        Constructor constructor = c.getDeclaredConstructor(int.class,String.class,int.class,boolean.class);
        Object obj2 = constructor.newInstance(1111,\"zhangsan\",18,true);
        System.out.println(obj2);
    }
}

通过反射机制获取一个类的父类和父接口

代码如下：

public class ReflectTest12 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName(\"java.lang.String\");
        //一个类最多只有一个父类
        Class superClass = c.getSuperclass();
        System.out.println(superClass.getName());
        //一个类可以实现多个接口
        Class[] superInterfaces = c.getInterfaces();
        for(Class i: superInterfaces){
            System.out.println(i.getName());
        }
    }
}

编译结果如下：