浅谈——Java反射机制

• 定义

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

• 功能

  1. 在运行时判断任意一个对象所属的类；

  2. 在运行时构造任意一个类的对象；

  3. 在运行时判断任意一个类所具有的成员变量和方法；

  4. 在运行时调用任意一个对象的方法；

  5. 生成动态代理。

• 相关API

通过对象获得相应的类名和包名

public class Test {
    public static void main(String[] args) {
        Person person = new Person("dx", 12);
        System.out.println(person.getClass().getName());
    }
}

输出：

dx.com.two.Person

实例化Class类对象

---

 public static void main(String[] args) throws Exception {
        Class class1 = null;
        Class class2 = null;
        Class class3 = null;
        try {
            class1 = Class.forName("dx.com.two.Person");
            class2 = new Test().getClass();
            class3 = dx.com.two.Person.class;
        } catch (ClassNotFoundException exception) {
            exception.printStackTrace();
        }

        System.out.println(class1.getName());
        System.out.println(class2.getName());
        System.out.println(class3.getName());

        //参数类型数组
        Class[] parameterType = new Class[]{String.class, int.class};
        //根据参数类型数组获取相应的构造函数
        Constructor<?> constructor = class1.getConstructor(parameterType);
        Person person = (Person) constructor.newInstance("dx", 12);
        System.out.println(person.toString());
    }

输出：

dx.com.two.Person
dx.com.Test
dx.com.two.Person
Person{name='dx', age=12}

获取一个对象的父类与继承的超类

---

public static void main(String[] args) throws Exception {
        Class sonClass = null;
        sonClass = Class.forName("dx.com.two.Son");
        Constructor constructor = sonClass.getConstructor(String.class, int.class);
        Son son = (Son) constructor.newInstance("dx", 12);
        System.out.println(son.toString());
        //根据子类获得的父类名构造父类对象
        System.out.println(son.getClass().getSuperclass().getName());
        Class fatherClass = son.getClass().getSuperclass();
        Constructor constructorFather = fatherClass.getConstructor(String.class, int.class);
        Father father = (Father) constructorFather.newInstance("wwj", 11);
        System.out.println(father.toString());
        //子类的超类
        AnnotatedType annotatedType = son.getClass().getAnnotatedSuperclass();
        System.out.println(annotatedType.getType());
        //父类的超类
        AnnotatedType annotatedTypeFather = father.getClass().getAnnotatedSuperclass();
        System.out.println(annotatedTypeFather.getType());
    }

输出：

Son{name='dx', age=12}
dx.com.two.Father
Father{name='wwj', age=11}
class dx.com.two.Father
class java.lang.Object

获取某个类中的全部构造函数

---

 public static void main(String[] args) throws Exception {
        Class fatherClass = Class.forName("dx.com.two.Father");
        Constructor[] constructors = fatherClass.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            System.out.println("第" + i + "个构造方法的参数为：");
            Class[] paramrters = constructors[i].getParameterTypes();
            for (int j = 0; j < paramrters.length; j++) {
                System.out.println(paramrters[j].getName());
            }
        }

结果

第0个构造方法的参数为：
java.lang.String
int
第1个构造方法的参数为：
java.lang.String
第2个构造方法的参数为：

获取某各类的所有属性

 Class fatherClass = Class.forName("dx.com.two.Father");
        Field[] fields = fatherClass.getDeclaredFields();
        for (Field filed : fields) {
            int i = filed.getModifiers();
            System.out.println("属性权限修饰符为：" + Modifier.toString(i));
            Class temp = filed.getType();
            System.out.println("属性类型为：" + temp.getName());
            System.out.println("属性值为：" + filed.toString());

结果

属性权限修饰符为：private
属性类型为：java.lang.String
属性值为：private java.lang.String dx.com.two.Father.name
属性权限修饰符为：private
属性类型为：int
属性值为：private int dx.com.two.Father.age

获取某个类的所有方法

      Class fatherClass = Class.forName("dx.com.two.Father");
        Method[] methods = fatherClass.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println("方法名为：" + methods[i].getName());
            System.out.println("方法的返回值类型为：" + methods[i].getReturnType().getName());
            int temp = methods[i].getModifiers();
            System.out.println("方法的修饰符为：" + Modifier.toString(temp));
            System.out.println("方法的参数为：");
            Class[] parameters = methods[i].getParameterTypes();
            for (int j = 0; j < parameters.length; j++) {
                System.out.println(parameters[j].getName());
            }
        }

输出：

方法名为：equals
方法的返回值类型为：boolean
方法的修饰符为：public
方法的参数为：
java.lang.Object
方法名为：toString
方法的返回值类型为：java.lang.String
方法的修饰符为：public
方法的参数为：
方法名为：hashCode
方法的返回值类型为：int
方法的修饰符为：public
方法的参数为：
方法名为：getName
方法的返回值类型为：java.lang.String
方法的修饰符为：public
方法的参数为：
方法名为：setName
方法的返回值类型为：void
方法的修饰符为：public
方法的参数为：
java.lang.String
方法名为：setAge
方法的返回值类型为：void
方法的修饰符为：public
方法的参数为：
int
方法名为：printPerson
方法的返回值类型为：void
方法的修饰符为：public static
方法的参数为：
方法名为：getAge
方法的返回值类型为：int
方法的修饰符为：public
方法的参数为：

通过反射机制调用某个类的方法

 Class fatherClass = Class.forName("dx.com.two.Father");
        Method method = fatherClass.getMethod("toString");
        System.out.println(method.invoke(fatherClass.newInstance()));

        Method method1 = fatherClass.getMethod("setName", String.class);
        method1.invoke(fatherClass.newInstance(), "dx");

输出：

Father{name='null', age=0}
姓名设置为：dx