Java核心类库-下（五）反射机制

---

5.1 基本概念

• 通常情况下编写代码都是固定的，无论运行多少次执行的结果也是固定的，在某些特殊场合中编写代码时不确定要创建什么类型的对象，也不确定要调用什么样的方法，这些都希望通过运行时传递的参数来决定，该机制叫做动态编程技术，也就是反射机制
• 通俗来说， 反射机制就是用于动态创建对象并且动态调用方法的机制
• 目前主流的框架底层都是采用反射机制实现的

---

5.2 Class类

基本概念

• java.lang.Class类的实例可以用于描述Java应用程序中的类和接口，也就是一种数据类型
• 该类没有公共构造方法，该类的实例由Java虚拟机和类加载器自动构造完成，本质上就是加载到内存中的运行时类

获取Class对象的方式

• 使用 数据类型.class 的方式可以获取对应类型的Class对象（掌握）
• 使用 Class.forName() 的方式来获取参数指定类型的Class对象（掌握）
  • 参数里的要求是完整式类名，即要加上包名，如java.lang.String
• 使用引用/对象.getClass()的方式可以获取对应类型的Class对象
• 使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象
• 使用类加载器ClassLoader的方式获取指定类型的Class对象

public class ClassTest {

    public static void main(String[] args) throws ClassNotFoundException {

        // 1.使用数据类型.class的方式来获取对象类型的Class对象
        Class c1 = String.class;
        System.out.println("c1 = " + c1);   // 自动调用toString方法， class java.lang.String
        c1 = int.class;
        System.out.println("c1 = " + c1);   // int
        c1 = void.class;
        System.out.println("c1 = " + c1);   // void

        // 2.使用引用/对象.getClass()的方式获取对象的Class对象
        String str1 = new String("Hello");
        c1 = str1.getClass();
        System.out.println("c1 = " + c1);   // class java.lang.String

        Integer it1 = 20;
        c1 = it1.getClass();
        System.out.println("c1 = " + c1);   // class java.lang.Integer

        int num = 5;
        //num.getClass();   // Error：基本数据类型的变量不能调用方法

        // 3.使用包装类.TYPE的方式来获取对象基本数据类型的Class对象
        c1 = Integer.TYPE;
        System.out.println("c1 = " + c1);   // int

        c1 = Integer.class;
        System.out.println("c1 = " + c1);   // class java.lang.Integer

        // 4.调用Class类中的forName方法来获取对象的Class对象
        //c1 = Class.forName("String");   // Error
        c1 = Class.forName("java.lang.String"); // 要从内存中加载，因此类名要完整
        System.out.println("c1 = " + c1);   // class java.lang.String

        c1 = Class.forName("java.util.Date");
        System.out.println("c1 = " + c1);   // class java.util.Date

        //c1 = Class.forName("int");
        //System.out.println("c1 = " + c1);   // Error：不能获取基本数据类型的Class对象

        // 5.使用类加载器的方式来获取Class对象
        // ClassLoader classLoader = String.class.getClassLoader();
        //System.out.println("classLoader = " + classLoader);     // null
        //c1 = classLoader.loadClass("java.lang.Integer");
        ClassLoader classLoader = ClassTest.class.getClassLoader();
        c1 = classLoader.loadClass("java.lang.Integer");
        System.out.println("c1 = " + c1);
    }
}

常用方法（掌握）

• 无参方式

public class PersonConstructorTest {

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

        // 1.原始方式
        Person p1 = new Person();
        System.out.println("p1 = " + p1);   // null 0

        // 2.使用反射机制以无参方式构造Person类型的对象
        // (1) 创建对象的类型可以凶从键盘中输入
        //System.out.println("请输入要创建对象的类型：");
        //Scanner sc = new Scanner(System.in);
        //String str1 = sc.next();
        // (2) 创建对象的类型可以从配置文件中读取
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/a.txt")));
        //BufferedReader br = new BufferedReader(new FileReader("d:/a.txt"));
        String str1 = br.readLine();
        Class c1 = Class.forName(str1);
        System.out.println(c1.newInstance());
        //sc.close();
        br.close();
    }
}

---

5.3 Constructor类

基本概念

• java.lang.reflect.Constructor类主要用于描述获取到的构造方法信息

Class类的常用方法

Constructor类的常用方法

---

• 无参方式

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/a.txt")));
String str1 = br.readLine();
Class c1 = Class.forName(str1);
Constructor constructor = c1.getConstructor();
// 使用获取到的无参构造方法来构造对应类型的对象，也就是Person类型的对象
System.out.println("无参方式创建的对象：" + constructor.newInstance()); // Person{name='null', age=0}
br.close();

---

• 有参方式

// 3.使用有参方式
Person p2 = new Person("张飞",30);
System.out.println(p2);

// 4.反射机制有参方式
// 获取Class对象对应类中的有参构造方法
Constructor constructor1 = c1.getConstructor(String.class, int.class);
// 构造对象
// newInstance方法中的实参是用于给有参构造方法中的形参进行初始化的
System.out.println(constructor1.newInstance("张飞",30));

---

• 获取所有公用构造方法的所有信息

// 5.反射机制获取Person类中所有公共构造方法
Constructor[] constructors = c1.getConstructors();
for (Constructor ct : constructors) {
    System.out.println("获取方法的访问修饰符：" + ct.getModifiers());  
        System.out.println("获取方法的名称：" + ct.getName());
        Class[] parameterTypes = ct.getParameterTypes();
    for (Class cl : parameterTypes) {
        System.out.println(cl);
    }
    System.out.println("--------------------------------");

---

5.4 field类

基本概念

• java.lang.reflect.Field类主要用于描述获取到的单个成员变量信息

Class类的常用方法

public class PersonField {

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

        // 1.原始方式
        Person p1 = new Person("张飞",30);
        System.out.println(p1.getName());

        // 2.使用反射机制来构造对象以及获取成员变量的数值
        // 2.1 获取Class对象
        Class c1 = Class.forName("com.lagou.task20.Person");
        // 2.2 根据Class对象获取对应的有参构造方法
        Constructor constructor = c1.getConstructor(String.class, int.class);
        // 2.3 使用有参构造方法来得到Person类型的对象
        Object obj = constructor.newInstance("张飞", 30);
        // 2.4 根据Class对象获取对应的成员变量的信息
        Field field = c1.getDeclaredField("name");
        // 设置Java语言访问检查的取消
        field.setAccessible(true);
        // 2.5 使用Person类型的对象来获取成员变量的数值
        // 获取对象obj中名字为field成员变量的数值，即成员变量name的数值
        System.out.println("获取到的成员变量数值为：" + field.get(obj)); // 张飞

        // 3.修改制定成员变量的数值
        // 原始方式
        p1.setName("guanyu");
        System.out.println(p1.getName()); // guanyu
        // 反射机制
        // 表示修改对象obj中名字为field成员变量的数值为liubei，即成员变量name的数值
        field.set(obj, "liubei");
        System.out.println(field.get(obj)); // liubei

        // 4.获取Class对象类中所有的成员变量
        Field[] declaredFields = c1.getDeclaredFields();
        for (Field ft : declaredFields) {
            System.out.println("获取访问修饰符：" + ft.getModifiers());
            System.out.println("获取成员变量名称：" + ft.getName());
            System.out.println("获取数据类型：" + ft.getType());
        }
    }
}

---

5.5 Method类

• java.lang.reflect.Method类主要用于描述获取到的单个成员方法信息

Class类中常用方法

Method类中常用方法

public class PersonMethodTest {

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

        // 1.使用原始方式构造对象并调用方法打印结果
        Person p1 = new Person("zhangfei", 30);
        System.out.println("调用方法的返回值是：" + p1.getName()); // zhangfei

        System.out.println("------------------------------------------------------");
        // 2.使用反射机制构造对象并调用方法打印结果
        // 2.1 获取Class对象
        Class c1 = Class.forName("com.lagou.task20.Person");
        // 2.2 根据Class对象来获取对应的有参构造方法
        Constructor constructor = c1.getConstructor(String.class, int.class);
        // 2.3 使用有参构造方法构造对象并记录
        Object object = constructor.newInstance("zhangfei", 30);
        // 2.4 根据Class对象来获取对应的成员方法
        Method method = c1.getMethod("getName");
        // 2.5 使用对象调用成员方法进行打印
        // 表示使用object对象调用method表示的方法，也就是调用getName方法来获取姓名
        System.out.println("调用方法的返回值是：" + method.invoke(object)); // zhangfei

        System.out.println("------------------------------------------------------");
        // 3.使用反射机制来获取类中的所有成员方法并打印
        Method[] methods = c1.getMethods();
        for (Method mt : methods) {
            System.out.println("成员方法的修饰符是：" + mt.getModifiers());
            System.out.println("成员方法的返回值类型是：" + mt.getReturnType());
            System.out.println("成员方法的名称是：" + mt.getName());
            System.out.println("成员方法形参列表的类型是：");
            Class<?>[] parameterTypes = mt.getParameterTypes();
            for (Class ct : parameterTypes) {
                System.out.print(ct + " ");
            }
            System.out.println();
            System.out.println("成员方法的异常类型列表是：");
            Class<?>[] exceptionTypes = mt.getExceptionTypes();
            for (Class ct: exceptionTypes) {
                System.out.print(ct + " ");
            }
            System.out.println();
            System.out.println("---------------------------------------------------");
        }
    }
}

---

5.6 获取其它结构信息

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

public class StudentTest {

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

        // 获取Student类型的Class对象
        Class c1 = Class.forName("com.lagou.task20.Student");
        System.out.println("获取到的包信息是：" + c1.getPackage());
        System.out.println("获取到的父类信息是：" + c1.getSuperclass());

        System.out.println("-------------------------------------------------");
        System.out.println("获取到的接口信息是：");
        Class[] interfaces = c1.getInterfaces();
        for (Class ct : interfaces) {
            System.out.print(ct + " ");
        }
        System.out.println();

        System.out.println("-------------------------------------------------");
        System.out.println("获取到的注解信息是：");
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation at : annotations) {
            System.out.print(at + " ");
        }
        System.out.println();

        System.out.println("-------------------------------------------------");
        System.out.println("获取到的泛型信息是：");
        Type[] genericInterfaces = c1.getGenericInterfaces();
        for (Type tt : genericInterfaces) {
            System.out.print(tt + " ");
        }
        System.out.println();
    }
}

@MyAnnotation
public class Student<T, E> extends Person implements Comparable<String>, Serializable {
    @Override
    public int compareTo(String o) {
        return 0;
    }
}

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}

---

总结

• 反射机制要理解透彻，为以后框架的学习打下基础
  

本文地址：https://blog.csdn.net/qq_23187859/article/details/107657000