反射相关类介绍

今天药忘吃喽~ 2024-04-06 12:26 34阅读 0赞

[CSDN话题挑战赛第2期][CSDN_2]  
参赛话题：[学习笔记][Link 1]

#### 反射相关类 ####

*   *   *  1. Class类
         *   *  1.1 基本介绍
             *  1.2 Class类常用方法
             *  1.3 获取Class类对象
             *  1.4 哪些类型有Class对象
         *  2. 类加载
         *   *  2.1 基本说明
             *  2.2 类加载时机
             *  2.3 类加载过程
         *  3. 通过反射获取类的信息结构
         *  4. 通过反射创建对象
         *  5. 通过反射访问类中的成员
         *   *  5.1 访问属性
             *  5.2 访问方法

#### 1. Class类 ####

##### 1.1 基本介绍 #####

1.  Class也是类，因此也继承Object类
2.  Class类对象不是new出来的，而是系统创建的
3.  对于某个类的Class对象，在内存中只有一份，因为类只加载一次
4.  每个类的实例都会记得自己是由那个Class实例所产生
5.  通过Class对象可以完整地得到一个类的完整结构，通过一系列API
6.  Class存放在堆中

##### 1.2 Class类常用方法 #####

我们直接看案例

String classAllPath = "com.zxy.Car";
    //1 . 获取到 Car 类 对应的 Class 对象
    //<?> 表示不确定的 Java 类型
    Class<?> cls = Class.forName(classAllPath);
    //2. 输出 cls
    System.out.println(cls); //显示 cls 对象, 是哪个类的 Class 对象 com.zxy.Car
    System.out.println(cls.getClass());//输出 cls 运行类型 java.lang.Class
    //3. 得到包名
    System.out.println(cls.getPackage().getName());//包名
    //4. 得到全类名
    System.out.println(cls.getName());
    //5. 通过 cls 创建对象实例
    Car car = (Car) cls.newInstance();
    System.out.println(car);//car.toString()
    //6. 通过反射获取属性 brand
    Field brand = cls.getField("brand");
    System.out.println(brand.get(car));//宝马
    //7. 通过反射给属性赋值
    brand.set(car, "奔驰");
    System.out.println(brand.get(car));//奔驰
    //8 我希望大家可以得到所有的属性(字段)
    System.out.println("=======所有的字段属性====");
    Field[] fields = cls.getFields();
    for (Field f : fields) {
        
    System.out.println(f.getName());//名称
    }

##### 1.3 获取Class类对象 #####

1.  已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，但有可能抛出找不到类的异常
2.  已知具体的类，通过类的Class获取，该方式最为安全可靠，程序性能也最高
3.  已知某个类的实例，调用该实例的getClass()方法获取Class对象
4.  其他方式
    
    ClassLoader cl = 对象.getClass().getClassLoader();
    
    Class clazz = cl.loadClass(“类的全类名”)
5.  基本数据类型
    
    Class cls = 基本数据类型.class
6.  基本数据类型对应的包装类
    
    Class cls = 包装类.TYPE

##### 1.4 哪些类型有Class对象 #####

1.  外部类，成员内部类，静态内部类，局部内部类，匿名内部类
2.  interface：接口
3.  数组
4.  enum：枚举
5.  annotation：注解
6.  基本数据类型
7.  void

#### 2. 类加载 ####

##### 2.1 基本说明 #####

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载

1.  静态加载：编译时加载相关的类，如果，没有则报错，依赖性太强
2.  动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错吗，降低了依赖性

##### 2.2 类加载时机 #####

1.  当创建对象时，（new）//静态加载
2.  当子类被加载时，父类也加载//静态加载
3.  调用类中的静态成员时//静态加载
4.  通过反射//动态加载

##### 2.3 类加载过程 #####

![在这里插入图片描述][e229f7e79d194418840298522b0829a8.png]

1.  加载loading：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
2.  连接Linking：将类的二级制数据合并到jre中。
3.  初始化：jvm负责对类进行初始化，这里主要是指静态成员。

#### 3. 通过反射获取类的信息结构 ####

> Class类

1.  getName：获取全类名
2.  getSimpleName：获取简单类名
3.  getFields：获取所有public修饰的属性，包含本类及父类的
4.  getDeclaredFields：获取本类中的所有属性
5.  getMethods：获取所有public修饰的方法，包含本类及父类的
6.  getDeclaredMethods：获取本类中的所有方法
7.  getConstructors：获取本类所有public修饰的构造器
8.  getDeclaredConstructors：获取本类中的所有构造器
9.  getPackage：以package形式返回包信息
10. getSuperClass：以Class形式返回父类信息
11. getInterfaces：以Class\[\]形式返回父类信息
12. getAnnotations：以Annotation\[\]形式返回注解信息

> Field类

1.  getModifiers：以int形式返回修饰符
    
    默认修饰符是0，public是1，private是2等等
2.  getReturnType：以Class形式获取返回类型
3.  getName：返回属性名

> Method类

1.  getModifiers：以int形式返回修饰符
    
    默认修饰符是0，public是1，private是2等等
2.  getReturnType：以Class形式获取返回类型
3.  getName：返回方法名
4.  getParameterTypes：以Class\[\]返回参数类型数组

> Consturctor类

1.  getModifiers：以int形式返回修饰符
    
    默认修饰符是0，public是1，private是2等等
2.  getName：返回构造器名（全类名）
3.  getParameterTypes：以Class\[\]返回参数类型数组

#### 4. 通过反射创建对象 ####

1.  方式一：调用类中的public修饰的无参构造器
2.  方式二：调用类中的指定构造器
3.  Class类相关方法
    
     *  newInstance: 调用类中的无参构造器，获取对应类的对象
     *  getConstructor:根据参数列表，获取对应的public构造器对象
     *  getDeclaredConstructors：根据参数列表获取对应的所有构造器
4.  Constructor类相关方法
    
     *  setAccessible：爆破
     *  newInstance：调用构造器

class User {
         //User 类
    private int age = 10;
    private String name = "波波";
    public User() {
        //无参 public
    }
    public User(String name) {
        //public 的有参构造器
    this.name = name;
    }
    private User(int age, String name) {
        //private 有参构造器
    this.age = age;
    this.name = name;
    }
    public String toString() {
        
    return "User [age=" + age + ", name=" + name + "]";
    }
    }

//1. 先获取到 User 类的 Class 对象
    Class<?> userClass = Class.forName("com.zxy.User");
    //2. 通过 public 的无参构造器创建实例
    Object o = userClass.newInstance();
    System.out.println(o);
    //3. 通过 public 的有参构造器创建实例
    /*
    constructor 对象就是
    public User(String name) {//public 的有参构造器
    this.name = name;
    }
    */
    //3.1 先得到对应构造器
    Constructor<?> constructor = userClass.getConstructor(String.class);
    //3.2 创建实例，并传入实参
    Object Jack = constructor.newInstance("Jack");
    System.out.println("Jack=" + Jack);
    //4. 通过非 public 的有参构造器创建实例
    //4.1 得到 private 的构造器对象
    Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
    //4.2 创建实例
    //暴破【暴力破解】 , 使用反射可以访问 private 构造器/方法/属性, 反射面前，都是纸老虎
    constructor1.setAccessible(true);
    Object user2 = constructor1.newInstance(100, "张三丰");
    System.out.println("user2=" + user2);

#### 5. 通过反射访问类中的成员 ####

##### 5.1 访问属性 #####

//1. 得到 Student 类对应的 Class 对象
    Class<?> stuClass = Class.forName("com.zxy.Student");
    //2. 创建对象
    Object o = stuClass.newInstance();//o 的运行类型就是 Student
    System.out.println(o.getClass());//Student
    //3. 使用反射得到 age 属性对象
    Field age = stuClass.getField("age");
    age.set(o, 88);//通过反射来操作属性
    System.out.println(o);//
    System.out.println(age.get(o));//返回 age 属性的值
    //4. 使用反射操作 name 属性
    Field name = stuClass.getDeclaredField("name");
    //对 name 进行暴破, 可以操作 private 属性
    name.setAccessible(true);
    //name.set(o, "波波");
    name.set(null, "波波~");//因为 name 是 static 属性，因此 o 也可以写出 null
    System.out.println(o);
    System.out.println(name.get(o)); //获取属性值
    System.out.println(name.get(null));//获取属性值, 要求 name 是 static

##### 5.2 访问方法 #####

//1. 得到 Boss 类对应的 Class 对象
    Class<?> bossCls = Class.forName("com.zxy.Boss");
    //2. 创建对象
    Object o = bossCls.newInstance();
    //3. 调用 public 的 hi 方法
    //Method hi = bossCls.getMethod("hi", String.class);//OK
    //3.1 得到 hi 方法对象
    Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
    //3.2 调用
    hi.invoke(o, "波波~");
    //4. 调用 private static 方法
    //4.1 得到 say 方法对象
    Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
    System.out.println(say.invoke(null, 200, "李四", '女'));

[CSDN_2]: https://marketing.csdn.net/p/7b6697fd9dd3795a268d1a6f2fe75012
[Link 1]: https://activity.csdn.net/creatActivity?id=10213
[e229f7e79d194418840298522b0829a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/9b1031ce16d0444384219725f436cb63.png