基本概念

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

Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象
p.show(); - 表示调用Person类中的成员方法show

Class类

基本概念

  • java.lang.Class类的实例可以用于描述Java应用程序中的类和接口，也就是一种数据类型。

  • 该类没有公共构造方法，该类的实例由Java虚拟机和类加载器自动构造完成，本质上就是加载到内存中的运行时类。

    获取Class对象的方式

  • 使用数据类型.class的方式可以获取对应类型的Class对象（掌握）。

  • 使用引用/对象.getClass()的方式可以获取对应类型的Class对象。
  • 使用包装类.TYPE的方式可以获取对应基本数据类型的Class对象。
  • 使用Class.forName()的方式来获取参数指定类型的Class对象（掌握）。
  • 使用类加载器ClassLoader的方式获取指定类型的Class对象。 ```java package com.lagou.task20;

/**

  • @author lijing
  • @date 2020/10/20 9:51

  • @description */ public class ClassTest { public static void main(String[] args) throws ClassNotFoundException {

    1.  //1.使用数据类型.class的方式可以获取对应类型的Class对象
    2.  Class c1=String.class;
    3.  System.out.println("c1="+c1);// class java.lang.String
    5.  //2.获取基本数据类型
    6.  c1=int.class;
    7.  System.out.println("c1="+c1);//int
    8.  c1=void.class;
    9.  System.out.println("c1="+c1);//void
    10.  System.out.println("------------------------------");
    12.  //2.使用对象.getClass()的方式获取相对应的Class对象
    13.  String  str1=new String("hello");
    14.  c1=str1.getClass();
    15.  System.out.println("c1=" + c1);//class java.lang.String
    17.  Integer it1=20;
    18.  c1=it1.getClass();
    19.  System.out.println("c1=" + c1);//class java.lang.Integer;
    21.  int num=5;

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

    1.  System.out.println("------------------------------");
    2.  //3.使用包装类.TYPE的方式来获取对应基本数据类型的Class对象
    3.  c1=Integer.TYPE;
    4.  System.out.println("c1=" + c1); //int
    5.  c1=Integer.class;
    6.  System.out.println("c1=" + c1); //class java.lang.Integer;
    7.  System.out.println("-------------------------------");
    8.  //4.调用Class类中的forName方式来获取对应的Class对象

// c1=Class.forName(“String”);//异常 c1=Class.forName(“java.lang.String”); System.out.println(“c1=” + c1);//class java.lang.String

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

// c1=Class.forName(“int”); // System.out.println(“c1=” + c1);不能获取基本数据类型的Class对象 System.out.println(“———————————————-“); //5.使用类加载器的方式来获取Class对象 ClassLoader classLoader = ClassTest.class.getClassLoader(); System.out.println(“类加载器=” + classLoader); c1= classLoader.loadClass(“java.lang.String”); System.out.println(“c1=”+c1); } }

  1. <a name="9wWYs"></a>
  2. ## 常用的方法（掌握）
  3. | 方法声明 | 功能介绍 |
  4. | --- | --- |
  5. | static Class<?> forName(String className)  | 用于获取参数指定类型对应的Class对象并返回 |
  6. | T newInstance()  | 用于创建该Class对象所表示类的新实例 |
  8. ```java
  9. //代码中看不出来是什么对象,运行阶段后才知道 
  10. //newInstance()使用
  11. package com.lagou.task20;
  13. import java.io.BufferedReader;
  14. import java.io.FileInputStream;
  15. import java.io.InputStreamReader;
  16. import java.util.Scanner;
  18. /**
  19.  * @author lijing
  20.  * @date 2020/10/20 10:08
  21.  * @description
  22.  */
  23. public class PersonConstructorTest {
  24.     public static void main(String[] args) throws Exception {
  25.         //1.使用原始方式以无参形式构造Person类型的对象
  26.         Person p1=new Person();
  27.         System.out.println("无参方式创建的对象是:"+p1);//null 0
  29.         System.out.println("---------------------------");
  30.         //2.使用反射机制以无参形式构造Person类型的对象并打印
  31.         Class c1=Class.forName("com.lagou.task20.Person");
  32.         System.out.println("无参方式创建的对象是:" + c1.newInstance());//null 0
  33.         //创建对象的类型可以从键盘输入
  34. //        System.out.println("请输入所需要的对象的类型:");
  35. //        Scanner sc=new Scanner(System.in);
  36. //        String str1=sc.next();
  37. //        c1=Class.forName(str1);
  38. //        System.out.println("输入的无参方式创建对象是:"+c1.newInstance());
  39. //        sc.close()
  40.         //创建对象的类型可以从配置文件中读取
  41.         BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt")));
  42.         String str2=br.readLine();
  43.         c1=Class.forName(str2);
  44.         System.out.println("输入的无参方式创建对象为:" + c1.newInstance());
  45.         br.close();
  46.     }
  47. }

Constructor类

基本概念

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

    Class类的常用方法

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

  1. //利用Constructor类和Class类中的getConstructor()方法获取
  2.         System.out.println("------------------------------------------------");
  3.         BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt")));
  4.         String str3=br.readLine();
  5.         c1=Class.forName(str3);
  6.         //获取Class对象对应类中的无参构造方法,也就是Person类中的无参构造方法
  7.         Constructor constructor = c1.getConstructor();
  8.         System.out.println("无参方式创建的对象是:" + constructor.newInstance());
  11.  //3.使用原始方式以有参方式构造Person类型的对象并打印
  12.         Person p2=new Person("张飞",30);
  13.         System.out.println("有参方式构造的对象时:"+p2);
  14.         //4.使用反射机制以有参方式构造Person类型的对象并打印
  15.         BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt")));
  16.         String str4=br.readLine();
  17.         c1=Class.forName(str4);
  18.         //获取Class对象对应类中的有参构造方法
  19.         Constructor constructor=c1.getConstructor(String.class, int.class);
  20.         //使用获取到的有参构造方法来构造对应类型的对象,也就是Person对象
  21.         //newInstance 方法中的实参是用于给有参构造方法的形参进行初始化的,也就是给name和age进行初始化
  22.         System.out.println("有参方式构造的对象时:" + constructor.newInstance("张飞", 30));

Constructor类的常用方法

方法声明 功能介绍
T newInstance(Object… initargs) 使用此Constructor对象描述的构造方法来构造Class对象代表类型的新实例
int getModifiers() 获取方法的访问修饰符
String getName() 获取方法的名称
Class<?>[] getParameterTypes() 获取方法所有参数的类型 
  1. BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt")));
  2.         String str4=br.readLine();
  3.         c1=Class.forName(str4);        
  4. //5.使用反射机制获取Person类中所有的公共构造方法并打印
  5.         Constructor[] constructors=c1.getConstructors();
  6.         for (Constructor ct :constructors) {
  7.             System.out.println("构造方法的访问修饰符是:" + ct.getModifiers());;
  8.             System.out.println("构造方法的方法名称是:" + ct.getName());
  9.             Class[] parameterTypes = ct.getParameterTypes();
  10.             System.out.println("构造方法中的所有参数类型是:");
  11.             for (Class cs :parameterTypes) {
  12.                 System.out.println(cs);
  13.             }
  14.             System.out.println();
  15.             System.out.println("-----------------");
  16.         }
  18.     }

Field类

基本概念

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

Class类的常用方法

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

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() 获取成员变量的名称 
  1. package com.lagou.task20;
  3. import java.io.BufferedReader;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.InputStreamReader;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.Field;
  10. /**
  11.  * @author lijing
  12.  * @date 2020/10/20 10:52
  13.  * @description
  14.  */
  15. public class PersonFileTest {
  16.     public static void main(String[] args) throws Exception {
  17.         //1.使用原始方式来构造对象以及获取成员变量的数值并打印
  18.         Person p1=new Person("张飞",30);
  19.         System.out.println("获取到的成员变量数值为:"+p1.getName());
  21.         //2.使用反射机制来构造对象以及获取成员变量的数值并打印
  22.         BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt")));
  23.         //2.1获取Class对象
  24.         String str1 = br.readLine();
  25.         Class c1=Class.forName(str1);
  26.         //2.2根据Class对象获取对应的有参构造方法
  27.         Constructor constructor = c1.getConstructor(String.class, int.class);
  28.         //2.3使用有参构造方法来得到PErson类型的对象
  29.         Object obj= constructor.newInstance("张飞", 30);
  30.         //2.4根据Class对象获取响应的成员变量信息
  31.         Field field = c1.getDeclaredField("name");
  32.         //设置java语言访问检查的取消  -->暴力反射
  33.         field.setAccessible(true);
  34.         //2.5使用Person类型的对象来获取成员变量的数值并打印
  35.         System.out.println("获取到的成员变量数值为:" + field.get(obj));
  37.         System.out.println("--------------------------------------");
  38.         //3.使用原始方式修改制定对象中成员变量的数值后,在从打印
  39.         p1.setName("关羽");
  40.         System.out.println("p1修改后的成员变量为:"+p1.getName());//关羽
  41.         //4.使用反射机制修改制定对象中成员变量的数值后再次打印
  42.         //表示修改对象object中名字为field成员变量的数值为关羽,也就是成员变量name的数值为关羽
  43.         field.set(obj,"关羽");
  44.         System.out.println("修改后成员变量的数值为:"+field.get(obj));
  47.         System.out.println("------------------------------------");
  48.         //5.获取Class对象对应类中所有的成员变量
  49.         Field[] declaredFields = c1.getDeclaredFields();
  50.         for (Field ft :declaredFields) {
  51.             System.out.println("获取到的访问修饰符为:" + ft.getModifiers());
  52.             System.out.println("获取到的数据类型为:" + ft.getType());
  53.             System.out.println("获取到的成员变量名称是:" + ft.getName());
  54.         }
  55.     }
  56. }

Method类

基本概念

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

Class类的常用方法

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

Method类的常用方法

方法声明 功能介绍
Object invoke(Object obj, Object… args) 使用对象obj来调用此Method对象所表示的成员方法，实参传递args
int getModifiers() 获取方法的访问修饰符
Class<?> getReturnType() 获取方法的返回值类型
String getName() 获取方法的名称
Class<?>[] getParameterTypes() 获取方法所有参数的类型
Class<?>[] getExceptionTypes() 获取方法的异常信息 
  1. package com.lagou.task20;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Method;
  6. /**
  7.  * @author lijing
  8.  * @date 2020/10/20 13:05
  9.  * @description
  10.  */
  11. public class PersonMethodTest {
  12.     public static void main(String[] args) throws Exception {
  13.         //1.使用原始方式构造对象并调用方法并打印结果
  14.         Person p1=new Person("张飞",30);
  15.         System.out.println("调用方法的返回值是:" + p1.getName());
  17.         System.out.println("---------------------------");
  18.         //2.使用反射机制构造对象并调用方法打印结果
  19.         //2.1获取Class对象
  20.         Class c1=Class.forName("com.lagou.task20.Person");
  21.         //2.2根据Class对象来获取对应的有参构造方法
  22.         Constructor constructor=c1.getConstructor(String.class,int.class);
  23.         //2.3使用有参构造方法构造对象并记录
  24.         Object obj = constructor.newInstance("张飞呀", 30);
  25.         //2.4根据Class对象来获取对应的成员方法
  26.         Method getName = c1.getMethod("getName");
  27.         //2.5使用对象调用成员方法进行打印
  28.         //表示使用object对象调用method表示的方法
  29.         System.out.println("调用方法的返回值是:" + getName.invoke(obj));
  31.         System.out.println("---------------------------");
  32.         //3.使用反射机制来获取类中的所有成员方法(公共的
  33.         Method[] methods = c1.getMethods();
  34.         for (Method mt :methods) {
  35.             System.out.println("成员方法的修饰符是:" + mt.getModifiers());
  36.             System.out.println("成员方法的返回值类型是:" + mt.getReturnType());
  37.             System.out.println("成员方法的名字是:" + mt.getName());
  38.             System.out.println("成员方法形参里列表的类型是");
  39.             for (Class ct :mt.getParameterTypes()) {
  40.                 System.out.print(ct+" ");
  41.             }
  42.             System.out.println();
  43.             System.out.println("成员方法的异常类型列表是:");
  44.             for (Class ct : mt.getExceptionTypes()) {
  45.                 System.out.print(ct+" ");
  46.             }
  47.             System.out.println();
  48.             System.out.println("--------------------------");
  49.         }
  50.     }
  51. }

获取其它结构信息

方法声明 功能介绍
Package getPackage() 获取所在的包信息
Class<? super T> getSuperclass() 获取继承的父类信息
Class<?>[] getInterfaces() 获取实现的所有接口
Annotation[] getAnnotations() 获取注解信息
Type[] getGenericInterfaces() 获取泛型信息 
  1. package com.lagou.task20;
  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Type;
  6. /**
  7.  * @author lijing
  8.  * @date 2020/10/20 13:20
  9.  * @description
  10.  */
  11. public class StudentTest {
  12.     public static void main(String[] args) throws Exception {
  13.         //获取Student类型的Class对象
  14.         Class c1=Class.forName("com.lagou.task20.Student");
  15.         System.out.println("获取到的包信息是:" + c1.getPackage());
  16.         System.out.println("获取到的父类信息是:" + c1.getSuperclass());
  17.         System.out.println("获取到的接口信息是:");
  18.         for (Class ct :c1.getInterfaces()) {
  19.             System.out.print(ct + " ");
  20.         }
  21.         System.out.println();
  22.         System.out.println("获取到的注解信息是:");
  23.         for (Annotation ct :c1.getAnnotations()) {
  24.             System.out.println(ct + " ");
  25.         }
  26.         System.out.println();
  27.         System.out.println("获取到的泛型信息是:");
  28.         Type[] genericInterfaces = c1.getGenericInterfaces();
  29.         for (Type gi :genericInterfaces) {
  30.             System.out.print(gi + " ");
  31.         }
  32.     }
  33. }

总结

反射机制:
概念 Class类 获取Class类的对象 获取指定的构造方法 获取所有的构造方法 获取指定的成员变量 获取所有的成员变量 获取指定的成员方法 获取所有的成员方法 获取其他结构等