【04 核心类库 7.反射机制】

7. 反射机制

7.1 基本概念

• 通常情况下编写代码都是固定的，无论运行多少次执行的结果也是固定的，在某些特殊场合中编写

  代码时不确定要创建什么类型的对象，也不确定要调用什么样的方法，这些都希望通过运行时传递

  的参数来决定，该机制叫做动态编程技术，也就是反射机制。

• 反射机制就是用于动态创建对象并且动态调用方法的机制。

• 目前主流的框架底层都是采用反射机制实现的。
  如：
  Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象

  ​ p.show(); - 表示调用Person类中的成员方法show

7.2 Class类

7.2.1 基本概念

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

7.2.2 获取Class对象的方式

• 使用数据类型.class的方式可以获取对应类型的Class对象（掌握）。(基本数据类型和引用数据类型是不同的)

  //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 = boolean.class;
          System.out.println("c1=" + c1);   //boolean
          c1 = void.class;
          System.out.println("c1=" + c1);   //void
  

• 使用引用/对象.getClass()的方式可以获取对应类型的Class对象。(不能获取基本数据类型的对象)

  //2.使用对象.getClass的方式获取对应类型的Class对象
          String str = new String("hello");
          c1 = str.getClass();
          System.out.println("c1=" + c1);   //class java.lang.String
  
          Integer it = 20;
          c1 = it.getClass();
          System.out.println("c1=" + c1);   //class java.lang.Integer
          System.out.println("-------------------------");
  
  		int num = 10;     //int不是类    num不是对象
  //        c1=num.getClass;  
  //基本数据类型的变量不能调用方法
  

• 使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象。

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

• 使用Class.forName()的方式来获取参数指定类型的Class对象（掌握）。(不能获取基本数据类型的对象)

  //4.通过调用Class类中的forName方法来获取对象的class对象
  //        c1=Class.forName("String");   Error   要求写完整的名称：包名.类名
          c1 = Class.forName("java.lang.Integer");
          System.out.println("c1=" + c1);     //java.lang.Integer
  
          c1 = Class.forName("java.util.Date");
          System.out.println("c1=" + c1);     //java.util.Date
  
  //        c1 = Class.forName("int");
  //        System.out.println("c1=" + c1);   不能获取基本数据类型的对象
          System.out.println("----------------------------------");
  

• 使用类加载器ClassLoader的方式获取指定类型的Class对象。

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

7.2.3 常用的方法（掌握）

方法声明	功能介绍
static Class<?> forName(String className)	用于获取参数指定类型对应的Class对象并返回
T newInstance()	用于创建该Class对象所表示类的新实例

 		Class c1 = Class.forName("demo05.Person");
        System.out.println("使用无参方式创建的对象是：" + c1.newInstance());

7.3 Constructor类

7.3.1 基本概念

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

7.3.2 Class类的常用方法

方法声明	功能介绍
Constructor getConstructor(Class<?>…parameterTypes)	用于获取此Class对象所表示类型中参数指定的公共构造方法
Constructor<?>[] getConstructors()	用于获取此Class对象所表示类型中所有的公共构造方法

		//2.1 获取Class对象
        Class c1 = Class.forName("demo05.Person");
        //2.2 根据Class对象来获取对应类型的有参构造方法
        Constructor constructor = c1.getConstructor(String.class, int.class);

7.3.3 Constructor类的常用方法

方法声明	功能介绍
T newInstance(Object…initargs)	使用此Constructor对象描述的构造方法来构造Class对象代表类型的新实例
int getModifiers()	获取方法的访问修饰符
String getName()	获取方法的名称
Class<?>[ ]getParameterTypes()	获取方法所有参数的类型

public class Person {
    public String name;
    private  int age;
    ......
        @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class PersonConstructorTest {
    public static void main(String[] args) throws Exception {
//1.使用原始方式以无参形式构造Person类型的对象
        Person p1 = new Person();
        System.out.println("使用无参方式创建的对象是：" + p1);
        System.out.println("-------------------------");

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

//3.获取Class对象对应类的类的无参构造方法，也就是Person类中的无参构造方法
        Constructor constructor = c1.getConstructor();
  //使用对象中的无参构造方法也构造对应类型的对象，也就是Person类型的对象
        System.out.println("使用无参方式构造的对象是：" + constructor.newInstance());
        System.out.println("---------------------------------------------");
  //获取Class对象对应类的有参构造方法类构造对象
        Constructor constructor1 = c1.getConstructor(String.class, int.class);
  //使用获取到的构造方法来构造对应类型的对象
  //newInstance方法中实参实际上是给有参构造方法中的形参进行初始化
        System.out.println("使用有参构造方式创建的对象是：" + constructor1.newInstance("阿七", 25));
        System.out.println("-------------------------------------");

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

7.4 Field类

7.4.1 基本概念

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

7.4.2 Class类的常用方法

方法声明	功能介绍
Field getDeclaredField(String name)	用于获取此Class对象所表示类中参数指定的单个成员变量信息
Field[] getDeclaredFields()	用于获取此Class对象所表示类中所有成员变量信息

 //1.使用原始方式来构造对象并获取成员变量并打印
        Person p1 = new Person("阿七", 25);
        System.out.println("获取到的成员变量的数值为：" + p1.name);
        System.out.println("-----------------------------");

//2.使用反射机制构造对象并获取成员变量并打印

        //2.1 获取Class对象
        Class c1 = Class.forName("demo05.Person");

        //2.2 根据Class对象来获取对应类型的有参构造方法
        Constructor constructor = c1.getConstructor(String.class, int.class);

        //2.3 使用有参构造方法来得到Person类型的对象
        Object object = constructor.newInstance("阿七", 25);

        //2.4 根据Class对象获取对应成员变量的信息
        Field field = c1.getDeclaredField("name");
        
        //设置Java语言访问的检查的取消  暴力反射
        field.setAccessible(true);      //当访问的成员变量为私有成员变量时
        
        //2.5 使用Person类型的对象来获取成员变量的数值并打印
        //获取对象object中名字为field成员变量的数值，也就是成员变量name的数值
        System.out.println("获取到的成员变量的数值为：" + field.get(object));
        System.out.println("-----------------------------------------");

//3.使用原始方式修改指定对象的成员变量的值并打印
        p1.name = "周扬";
        System.out.println("修改后的成员变量的值为：" + p1.name);

//4.使用反射机制来修改指定对象的成员变量的值
        //修改对象object中名字为field成员变量的数值
        field.set(object, "周扬");
        System.out.println("修改后的成员变量的值为：" + field.get(object));
        System.out.println("------------------------------");

7.4.3 Field类的常用方法

方法声明	功能介绍
Object get(Object obj)	获取参数对象obj中此Field对象所表示成员变量的数值
void set(Object obj, Object value)	将参数对象obj中此Field对象表示成员变量的数值修改为参数value的数值
void setAccessible(boolean flag)	当实参传递true时，则反射对象在使用时应该取消 Java 语言访问检查
int getModifiers()	获取成员变量的访问修饰符
Class<?> getType()	获取成员变量的数据类型
String getName()	获取成员变量的名称

//设置Java语言访问的检查的取消  暴力反射
        field.setAccessible(true);      //当访问的成员变量为私有成员变量时

//修改对象object中名字为field成员变量的数值
        field.set(object, "周扬");

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

7.5 Method类

7.5.1 基本概念

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

7.5.2 Class类的常用方法

方法声明	功能介绍
Method getMethod(String name,Class<?>… parameterTypes)	用于获取该Class对象表示类中名字为name参数为parameterTypes的指定公共成员方法
Method[] getMethods()	用于获取该Class对象表示类中所有公共成员方法

7.5.3 Method类的常用方法

方法声明	功能介绍
Object invoke(Object obj,Object… args)	使用对象obj来调用此Method对象所表示的成员方法，实参传递args
int getModifiers()	获取方法的访问修饰符
Class<?> getReturnType()	获取方法的返回值类型
String getName()	获取方法的名称
Class<?>[] getParameterTypes()	获取方法所有参数的类型
Class<?>[] getExceptionTypes()	获取方法的异常信息

package demo05;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class PersonMethodTest {
    public static void main(String[] args) throws Exception {
        //1.使用原始方式构造对象并调用方法打印结果
        Person p1 = new Person("海棠", 18);
        System.out.println("调用方法的返回值为：" + p1.getName());
        System.out.println("-------------------------------");

        //2.使用反射机制构造对象并调用方法打印结果
        //2.1 获取Class对象
        Class c1 = Class.forName("demo05.Person");
        //2.2 根据Class对象来获取对应的有参构造方法
        Constructor constructor = c1.getConstructor(String.class, int.class);
        //2.3 使用有参构造方法来构造对象并记录
        Object object = constructor.newInstance("海棠", 18);
        //2.4 根据Class对象来获取对应的成员方法
        Method method = c1.getMethod("getName");
        //2.5 使用对象调用成员方法并打印
        //表示使用object对象调用method表示的方法，也就是调用getName方法来获取名字
        System.out.println("调用方法的返回值为：" + method.invoke(object)); //海棠
        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.print("成员方法的形参列表是：");
            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("-------------------------");
        }
    }
}

7.6 获取其它结构信息

方法声明	功能介绍
Package getPackage()	获取所在的包信息
Class<? super T> getSuperclass()	获取继承的父类信息
Class<?>[] getInterfaces()	获取实现的所有接口
Annotation[] getAnnotations()	获取注解信息
Type[] getGenericInterfaces()	获取泛型信息

//父类
public class Person {
    public String name;
    private  int age;
    ......
        @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//子类
package demo05;

import java.io.Serializable;

@MyAnnotation
public class Student<T,E> extends Person implements Comparable<String>, Serializable {      //指定的泛型信息
    @Override
    public int compareTo(String o) {
        return 0;
    }
}

public class StudentTest {
    public static void main(String[] args) throws Exception {
        //获取Student类型的Class对象
        Class c1 = Class.forName("demo05.Student");
        System.out.println("获取到的包信息是：" + c1.getPackage());
        System.out.println("获取到的父类信息是：" + c1.getSuperclass());
        System.out.println("---------------------------------");

        System.out.println("获取到的接口信息是：");
        Class[] interfaces = c1.getInterfaces();
        for (Class ca : interfaces) {
            System.out.print(ca+" ");
        }
        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("---------------------------------");
        //泛型
        Type[] genericInterfaces = c1.getGenericInterfaces();
        for (Type tp:genericInterfaces) {
            System.out.print(tp+" ");
        }
        System.out.println();
    }
}