java 反射机制笔记

使用反射操作类的成员的前提条件是：要获得该类的字节码文件对象，就是Class对象。

Class对象获取的方式

public class Test {
    /**
     * Class对象获取的方式
     * 1，类名.class
     * 2，对象名.getClass()
     * 3，通过Class类的静态方法forName("类全名")获得
     */
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一
        Class<Person> personClass = Person.class;

        //方式二
        Person person = new Person();
        Class<? extends Person> aClass = person.getClass();

        //方式三
        Class<?> aClass1 = Class.forName("com.反射.Person");
    }
}
class Person{
    static {
        System.out.println("类加载了");
    }
}

Class类常用方法

public class Test2 {
    /**
     * Class类常用方法
     * String getSimpleName():获得类名字符串：类名
     * String getName():获得类全名字符串：包名+类名
     * T newInstanc()：创建Class对象关联类的对象
     */
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        //获取student类的class对象
        Class<Student> studentClass = Student.class;
        //获得类名:Student
        System.out.println(studentClass.getSimpleName());
        //获得类全名
        System.out.println(studentClass.getName());
        //创建Class对象关联类的对象
        Student student = studentClass.newInstance();
    }
}

class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

反射之构造方法

/**
 * 反射之构造方法
 *  ConStructor类的概述：
 *  作用：获得到ConStructor对象来创建类的对象
 *  可以通过反射获取类的构造方法
 *  可以通过反射执行类的构造方法
 *  【可以通过反射获取类的构造方法】
 *  Class对象中，与Constructor有关的方法
 *      Constructor<T> getConstructor(类<?>... parameterTypes)
 *      根据参数类型获取Constructor对象，只能获取用public修饰的构造方法
 *      返回一个 Constructor对象，该对象反映 Constructor对象表示的类的指定的公共 类函数。
 *      Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
 *      根据参数类型获取Constructor对象，可以获取由public,protected(默认)，private参数修饰的构造方法
 *      返回一个 Constructor对象，该对象反映 Constructor对象表示的类或接口的指定 类函数。
 *      Constructor<?>[]   getConstructors()
 *      只能获取用public修饰的所有的构造方法
 *      返回包含一个数组 Constructor对象反射由此表示的类的所有公共构造 类对象。
 *      Constructor<?>[]   getDeclaredConstructors()
 *      获取由public,protected(默认)，private参数修饰的所有的构造方法
 *      返回一个反映 Constructor对象表示的类声明的所有 Constructor对象的数组 类 。
 *
 *      【可以通过反射执行类的构造方法】
 *      Constructor类常用方法：
 *      1，T newInstance(Object... initargs)
 *      根据指定参数创建对象
 *      参数：传入执行构造方法所需要的实际参数
 *      2，void setAccessible(true)
 *      设置暴力反射，参数：是否取消检查，true取消权限检查，false表示不取消检查
 */

public class Test3 {
    /**
     * 反射之构造方法
     *  ConStructor类的概述：
     *  作用：获得到ConStructor对象来创建类的对象
     *  可以通过反射获取类的构造方法
     *  可以通过反射执行类的构造方法
     *  【可以通过反射获取类的构造方法】
     *  Class对象中，与Constructor有关的方法
     *      Constructor<T>	getConstructor(类<?>... parameterTypes)
     *      根据参数类型获取Constructor对象，只能获取用public修饰的构造方法
     *      返回一个 Constructor对象，该对象反映 Constructor对象表示的类的指定的公共 类函数。
     *      Constructor<T>	getDeclaredConstructor(类<?>... parameterTypes)
     *      根据参数类型获取Constructor对象，可以获取由public,protected(默认)，private参数修饰的构造方法
     *      返回一个 Constructor对象，该对象反映 Constructor对象表示的类或接口的指定 类函数。
     *      Constructor<?>[]	getConstructors()
     *      只能获取用public修饰的所有的构造方法
     *      返回包含一个数组 Constructor对象反射由此表示的类的所有公共构造 类对象。
     *      Constructor<?>[]	getDeclaredConstructors()
     *      获取由public,protected(默认)，private参数修饰的所有的构造方法
     *      返回一个反映 Constructor对象表示的类声明的所有 Constructor对象的数组 类 。
     *
     *      【可以通过反射执行类的构造方法】
     *      Constructor类常用方法：
     *      1，T newInstance(Object... initargs)
     *      根据指定参数创建对象
     *      参数：传入执行构造方法所需要的实际参数
     *      2，void setAccessible(true)
     *      设置暴力反射，参数：是否取消检查，true取消权限检查，false表示不取消检查
     */
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //案例
        //首先获取Class对象
        Class<Workers> workersClass = Workers.class;
        //通过class对象获取构造方法,参数传构造方法的参数类型的Class对象
        Constructor<Workers> constructor = workersClass.getConstructor(String.class, int.class);
        //打印public com.反射.Workers(java.lang.String,int)
        System.out.println(constructor);

        //私有构造需要暴力反射，取消权限检查
        constructor.setAccessible(true);

        //通过Constructor的newInstance方法创建对象
        Workers zhangsan = constructor.newInstance("张三", 18);
        System.out.println(zhangsan);
    }
}
class Workers{
    private String name;
    private int age;
    public Workers(){}
    public Workers(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Workers worker = (Workers) o;
        return age == worker.age && Objects.equals(name, worker.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

反射之成员方法

public class Test4 {
    /**
     * 反射之成员方法
     * Method类
     * 概述：每一个成员方法都是一个Method类对象
     * 作用：操作Method对象就可以调用对应的成员方法
     * 【通过反射获取类的成员方法】
     *  Class类中与Method类相关的方法
     *  Method	getMethod(String name, 类<?>... parameterTypes)
     *  返回一个 方法对象，它反映此表示的类或接口的指定公共成员方法 类对象。
     *  Method	getDeclaredMethod(String name, 类<?>... parameterTypes)
     *  返回一个 方法对象，它反映此表示的类或接口的指定声明的方法 类对象。
     *  Method[]	getMethods()
     *  返回包含一个数组 方法对象反射由此表示的类或接口的所有公共方法 类对象，包括那些由类或接口和那些从超类和超接口继承的声明。
     *  Method[]	getDeclaredMethods()
     *  返回包含一个数组 方法对象反射的类或接口的所有声明的方法，通过此表示 类对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。
     *
     * 【通过反射执行成员方法】
     *  Method类
     *  1，Object invoke(Object obj,Object... args)
     *  执行成员方法
     *  参数一：调用该方法需要的对象
     *  参数二，传递的参数
     *  2，void setAccessible(true)
     *   设置暴力反射，参数：是否取消检查，true取消权限检查，false表示不取消检查
     */
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        //
        Class<School> schoolClass = School.class;

        Method sy = schoolClass.getDeclaredMethod("sy");
        System.out.println(sy);
        //暴力反射
        sy.setAccessible(true);
        School school = schoolClass.newInstance();
        sy.invoke(school);
    }
}

public class School {
    private String name;
    private String addr;
    private Integer student_number;

    public School(){}

    public School(String name, String addr, Integer student_number) {
        this.name = name;
        this.addr = addr;
        this.student_number = student_number;
    }

    private void sy(){
        System.out.println("这是一个私有的成员方法");
    }

    private int  sy(int i){
        System.out.println("这是一个私有的有参数，有返回值的成员方法");
        return i;
    }

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public Integer getStudent_number() {
        return student_number;
    }

    public void setStudent_number(Integer student_number) {
        this.student_number = student_number;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        School school = (School) o;
        return Objects.equals(name, school.name) && Objects.equals(addr, school.addr) && Objects.equals(student_number, school.student_number);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, addr, student_number);
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", addr='" + addr + '\'' +
                ", student_number=" + student_number +
                '}';
    }
}

反射之成员变量

public class Test5 {
    /**
     * 反射之成员变量
     * Field类，通过Field类可以给类的成员变量赋值和取值
     * 概述：每一个成员变量都是一个Filed类
     *
     * 【通过反射获取成员变量】
     * Class类与Field类相关的方法
     *      Field	getField(String name)
     *      返回一个 Field对象，它反映此表示的类或接口的指定公共成员字段 类对象。
     *      Field	getDeclaredField(String name)
     *      返回一个 Field对象，它反映此表示的类或接口的指定已声明字段 类对象。
     *      Field[]	getFields()
     *      返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段 类对象。
     *      Field[]	getDeclaredFields()
     *      返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。
     * 【通过反射使用成员变量】
     *
     */
    public static void main(String[] args) throws NoSuchFieldException, InstantiationException, IllegalAccessException {
        Class<School> schoolClass = School.class;
        Field name = schoolClass.getDeclaredField("name");

        School school = schoolClass.newInstance();
        //开启暴力反射
        name.setAccessible(true);
        name.set(school,"张三");
        System.out.println(name.get(school));
        //获取成员变量类型:class java.lang.String
        System.out.println(name.getType());
        
    }
}