java-反射机制

简述

反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息（如成员变量，构造器，成员方法等），并能操作对象的属性及方法。反射机制在设计模式和框架底层都能用到。

        类一旦加载，在堆中会产生一个Class类型的对象，这个对象包含了类的完整结构信息。通过这个对象可以获得这个类的结构

java反射机制相关类

         java作为面向对象的编程语言，万物皆对象，在反射机制中，将类的各个成员都当做一个类的对象

    ①java.lang.Class:Class对象表示某个类加载后在堆中的对象
    ②java.lang.reflect.Method:代表类的方法
    ③java.lang.reflect.Field:代表类的成员变量
    ④java.lang.reflect.Constructor:代表类的构造器

反射机制优缺点 

优点：可以动态的创建和使用对象，使用灵活，反射机制就是框架的底层支撑
缺点：使用反射的运行效率较慢

 反射机制优化

    关闭访问检查，Method，Field，Constructor均有setAccessible(boolean b)方法，作用是开启或关闭访问安全检查开关，参数为true时关闭访问检查，提高反射的效率；参数为false则表示开启访问检查

Class 

①Class类也是一个类，只是类名就叫做Class，因此也继承Object类
②Class类对象不是new Class()的形式创建的，而是由系统创建
③对于某一个类的Class类对象，在内存中只有一份，因此类在内存中只加载一次
④通过Class类对象可以获取所加载类的所有接信息
⑤Class对象存放在堆中。

具有Class对象的类型 

类，接口，数组，枚举，注解，基本数据类型，void

代码示例:

package com.flash.class_;
 
import java.io.Serializable;
 
/**
 * @author flash
 * @date 2024/06/18 18:08
 * 功能描述:枚举拥有 Class 对象的类型
 */
public class AllTypeClass {
    public static void main(String[] args) {
        // 类
        Class<String> cls1 = String.class;
        // 接口
        Class<Serializable> cls2 = Serializable.class;
        // 一维数组
        Class<Integer[]> cls3 = Integer[].class;
        // 二维数组
        Class<float[][]> cls4 = float[][].class;
        // 注解
        Class<Deprecated> cls5 = Deprecated.class;
        // 枚举
        Class<Thread.State> cls6 = Thread.State.class;
        // 基本数据类型
        Class<Long> cls7 = long.class;
        // void
        Class<Void> cls8 = void.class;
        // Class
        Class<Class> cls9 = Class.class;
 
        System.out.println("cls1 = " + cls1);
        System.out.println("cls2 = " + cls2);
        System.out.println("cls3 = " + cls3);
        System.out.println("cls4 = " + cls4);
        System.out.println("cls5 = " + cls5);
        System.out.println("cls6 = " + cls6);
        System.out.println("cls7 = " + cls7);
        System.out.println("cls8 = " + cls8);
        System.out.println("cls9 = " + cls9);
    }
}

 类加载

基本说明:反射机制是java实现动态语言的关键, 也就是通过反射实现类动态加载
        ①静态加载:编译时加载相关的类, 如果没有直接报错, 依赖性强
        ②动态加载:运行时加载需要的类, 如果运行时没有用到该类, 即使不存在这个类也不会报错, 依赖性较弱
类加载时机:
        ①当创建对象时(new) 静态加载
        ②当子类被加载时, 父类也被加载 静态加载
        ③调用类中的静态成员时 静态加载
        ④反射机制 动态加载

Class类对象创建方式 

package com.ffyc.javareflect;

public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //以前使用类,已知类名:new创建对象,调用对象成员
        // User user =new User();
        //user.eat();

        //1使用反射机制时,只知道类的名称(包名+类名)
        String classname  = "com.ffyc.javareflect.User";
        //如何类的信息?可以通过class 类来获得类中的信息

        //如何获得类的Class对象?
        // 方式1:

        Class clazz1 = Class.forName(classname);
        System.out.println(clazz1);

        //方式2:
        Class clazz2 = User.class;
        System.out.println(clazz1==clazz2);

        //方式3:
        User user = new User();
        Class clazz3 = user.getClass();
        System.out.println(clazz1==clazz3);
    }
}

运行结果： 

反射获取类的结构信息

代码示例：

class PersonDad {
    public String dept;
 
    public PersonDad() {
    }
 
    public PersonDad(String dept) {
        this.dept = dept;
    }
 
    public void dadMethod() {
    }
}
 
interface PersonInterface {
 
}
 
@Deprecated // 弃用注解
class Person extends PersonDad implements PersonInterface {
    // 属性
    public String name = "JSON";
    protected int age = 20;
    String job = "study";
    private double sal = -100;
    static int a;
    final int b = 10;
 
    public Person() {
    }
 
    public Person(String name) {
        this.name = name;
    }
 
    private Person(String dept, String job) {
        super(dept);
        this.job = job;
    }
 
 
    protected Person(String name, String job, String dept) {
        super(dept);
        this.name = name;
        this.job = job;
    }
 
    public Person(String dept, String name, int age, String job, double sal) {
        super(dept);
        this.name = name;
        this.age = age;
        this.job = job;
        this.sal = sal;
    }
 
    // 方法
    public void m1(String name, int age) {
    }
 
    protected int m2() {
        return 0;
    }
 
    String m3() {
        return null;
    }
 
    private void m4() {
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                ", b=" + b +
                '}';
    }
}

获取方法

package com.ffyc.javareflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
                /*
        java中创建对象的方式:
        1.new
        2.反序列化
        3.反射机制

        */
        //使用反射机制时,只知道类的名称(包名+类名)
        String classname ="com.ffyc.javareflect.User";
        //string classname ="com.ffyc.javareflect.Car";

        //1.通过类名 获得到类的class 对象
        Class aClass =Class.forName(classname);

        //2.通过类的class 对象  创建对象
        Object object = aClass.newInstance();
        System.out.println(object);

        //获得类中的构造方法   通过构造方法api中的方法创建对象
        Constructor constructor1 = aClass.getConstructor();;//获得指定的公共构造方法
        Object object1 = constructor1.newInstance();
        Constructor constructor2 = aClass.getConstructor(String.class,String.class);

        Object object2 = constructor2.newInstance("张三","111");
        System.out.println(object1);
        System.out.println(object2);

        Constructor [] constructors = aClass.getConstructors();//获得所有的公共构造方法
        System.out.println(constructors.length);

        //虽然可以获得私有构造方法 但一般不建议操作 因为打破了封装性
        aClass.getDeclaredConstructor();//获得类中任意的构造方法  包含私有的
        System.out.println(aClass.getDeclaredAnnotations().length);

    }
}