java反射

反射介绍

​ 反射（Reflect）：Java中提供一种可以在运行时操作任意类中的属性和方法的技术。

​ 反射在运行之前是不需要类中结构的，运行过程中，只要能够获取该类的字节码文件, 就可以随意修改类中属性的值，随意调用类中方法。让程序变得非常灵活。

反射的优缺点

​ 优点：灵活性和扩展性。

​ 缺点：性能问题。因为反射是在运行过程中操作字节码文件，要比直接使用代码操作内容慢很多。

​ 总结：反射主要使用在对灵活性和扩展性要求比较高的框架中。普通代码不建议使用。

Class类

java.lang.Class 表示类的类型。一个Class类对象就代表了某个类的字节码对象。获取到这个类的字节码对象后该类中所有的内容都会被知道，然后就可以对这个类进行操作。

Class类是Java 反射机制的起源和入口 / 用于获取与类相关的各种信息 /提供了获取类信息的相关方法/ Class类继承自Object类

创建Class对象

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        Class stringClass = String.class;
        //第一种方式
        Class aClass = Class.forName("com.lee.classtest.User");

        //第二种方式
        Class integerClass = int.class;
        Class stringClass1 = String.class;
        Class userClass = User.class;
//        System.out.println(userClass);

        //第三种方式
        User user = new User();
        Class userClass2 = user.getClass();
//        System.out.println(userClass2);
    }
}

常用方法

public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
        Class clazz = User.class;
        //常用方法
        System.out.println(clazz.getName());
        System.out.println(clazz.getSimpleName());
        System.out.println(clazz.getSuperclass());
        System.out.println(Arrays.toString(clazz.getInterfaces()));

        //获得构造函数
        //获得所有使用public修饰的构造函数
        Constructor[] constructors = clazz.getConstructors();
        //获得使用public修饰的无参构造
        Constructor constructor = clazz.getConstructor();
        //获得使用public修饰的指定有参构造
        Constructor constructor1 = clazz.getConstructor(int.class, String.class);


        //获得所有权限修饰符修饰的构造方法
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        //获得所有权限修饰符修饰的无参构造方法
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
        //获得所有权限修饰符修饰的指定有参构造方法
        Constructor declaredConstructor1 = clazz.getDeclaredConstructor(int.class, String.class);
        System.out.println(declaredConstructor1);


        //获取属性/成员变量
        //获得使用public修饰的成员变量  子类和父类
        Field[] fields = clazz.getFields();
        //获得使用public修饰的某一个成员变量
        Field age = clazz.getField("name");
        //获得使用任意修饰符修饰的变量 *这种方式不可以获得父类中成员变量
        Field[] declaredFields = clazz.getDeclaredFields();
        //获得使用任意修饰符修饰的变量 不可以获得父类
        Field age1 = clazz.getDeclaredField("age");
//        System.out.println(Arrays.toString(fields));

        //获取成员方法
        //获取使用public修饰的成员方法  子类和父类
        Method[] methods = clazz.getMethods();
        //获取使用public修饰的指定成员方法  子类和父类
        Method method = clazz.getMethod("getAge");
        //获得使用任意修饰符修饰的方法  子类
        Method[] declaredMethods = clazz.getDeclaredMethods();
        //获得使用任意修饰符修饰的指定方法  子类
        Method setName = clazz.getDeclaredMethod("setName", String.class);

    }


public class User extends People {
    private int age;
    public String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public User() {
    }

    public int getAge()  {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

实例化对象

方法1：通过Class的newInstance()方法

• 该方法要求该Class对象的对应类有无参构造方法
• 执行newInstance()实际上就是执行无参构造方法来创建该类的实例

方法2：通过Constructor的newInstance()方法

• 先使用Class对象获取指定的Constructor对象
• 再调用Constructor对象的newInstance()创建Class对象对应类的对象
• 通过该方法可选择使用指定构造方法来创建对象

public class TestC {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class clazz = Class.forName("com.lee.classtest.User");
        //创建类对象
        //无参
//        Object o = clazz.getConstructor().newInstance();

//        有参
        Object o = clazz.getConstructor(int.class, String.class).newInstance(12, "zs");

        //给对象属性赋值
        Field age = clazz.getDeclaredField("age");
        age.setAccessible(true); //突破权限修饰符限制  可修改私有属性
        age.set(o, 16); //o.age=16
        System.out.println(o);//User{age=16, name='zs'}

        //反射操作方法
        Method setName = clazz.getMethod("setName", String.class);
        setName.invoke(o, "ls");
        System.out.println(o); //User{age=16, name='ls'}

    }
}

反射突破泛型

public class TestD {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //反射突破泛型
        List<String> list = new ArrayList<>();
        Class aClass = list.getClass();
        Method add = aClass.getMethod("add", Object.class);
        //可以添加任意类型数据
        add.invoke(list,1);
        add.invoke(list,'a');
        add.invoke(list,"abc");
        add.invoke(list,true);
        add.invoke(list,new Date());
        System.out.println(list);

    }
}
//[1, a, abc, true, Wed Mar 30 20:04:05 CST 2022]