反射的基本入门

2301_76933484

已于 2023-09-13 23:57:31 修改

阅读量22

点赞数

文章标签： java servlet 开发语言

于 2023-09-13 20:25:47 首次发布

本文链接：https://blog.csdn.net/2301_76933484/article/details/132864079

版权

一、概念

反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。

二、利用反射技术获取的类型

1.获取类的字节码对象

// 学生类
public class Student {
    private String name;
    private int age;
    private char sex;

    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;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

public class Test1Class {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一：类名.class
        Class<Student> class1 = Student.class;
        //1.获取全类名
        System.out.println(class1.getName()); //com.itheima.反射.一_获取字节码对象.Student
        //2.获取简单类名
        System.out.println(class1.getSimpleName()); //Student

        //方式二：对象.getClass()
        Student stu = new Student();
        Class<? extends Student> class2 = stu.getClass();
        //1.获取全类名
        System.out.println(class2.getName()); //com.itheima.反射.一_获取字节码对象.Student
        //2.获取简单类名
        System.out.println(class2.getSimpleName()); //Student

        //方式三：通过Class.forName()方法，括号里传递类的全限定名（全限定名：包名+类名）
        Class<?> class3 = Class.forName("com.itheima.反射.一_获取类的字节码对象.Student");
        //1.获取全类名
        System.out.println(class3.getName()); //com.itheima.反射.一_获取字节码对象.Student
        //2.获取简单类名
        System.out.println(class3.getSimpleName()); //Student

        //比较结果是true，因为每个类的字节码对象是一个
        System.out.println(class2 == class3); //true
    }
}

2.获取类的构造器

// 猫类
public class Cat {
    private String name;
    private int age;

    public Cat() {
        System.out.println("无参构造执行了~~~");
    }

    //私有的有参构造
    private Cat(String name, int age) {
        System.out.println("有参构造执行了~~~~~~");
        this.name = name;
        this.age = age;
    }

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

public class ConstructorDemo {

    /**
     * 一、获取全部构造器
     */
    @Test
    public void testConstructors() {
        //1、反射第一步：必须先得到这个类的Class对象
        Class<Cat> clazz = Cat.class;

        //2.1、获取类的全部构造器（只能获取public修饰的公开的构造方法）
        Constructor<?>[] con1 = clazz.getConstructors();

        //3.2、遍历数组中的每一个构造器对象
        for (Constructor<?> constructor : con1) {
            System.out.println("参数名字：" + constructor.getName() + "-->参数个数：" + constructor.getParameterCount());
        }

        System.out.println("------------------------------------------------");

        //2.2、获取类的全部构造器（获取所有已定义的构造方法）
        Constructor<?>[] con2 = clazz.getDeclaredConstructors();

        //3.2、遍历数组中的每一个构造器对象
        for (Constructor<?> constructor : con2) {
            System.out.println("参数名字：" + constructor.getName() + "-->参数个数：" + constructor.getParameterCount());
        }

    }

    /**
     * 二、1 获取某个构造器（只能获取public修饰的）
     */
    @Test
    public void testConstructor() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1、反射第一步：必须先得到这个类的字节码对象
        Class<Cat> clazz = Cat.class;

        //2、获取被public修饰的空参数构造器（只能获取public修饰的公开的构造方法）
        Constructor<Cat> con1 = clazz.getConstructor();

        //3、public T newInstance(Object... initargs) ： 通过构造方法创建对象  [initargs：表示初始化参数]
        Cat cat = con1.newInstance();
        System.out.println(cat);
    }

    /**
     * 二、2 获取某个构造器（只要存在就能拿到）
     */
    @Test
    public void testConstructor2() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1、反射第一步：必须先得到这个类的字节码对象
        Class<Cat> clazz = Cat.class;

        //2、获取指定的构造方法
        Constructor<Cat> con = clazz.getDeclaredConstructor(String.class, int.class);

        //3、取消访问权限限制（即使private修饰，也可以使用）（设置为true，表示禁止检查访问控制） 【暴力反射】
        con.setAccessible(true);

        //4、public T newInstance(Object... initargs) ： 通过构造方法创建对象  [initargs：表示初始化参数]
        Cat cat = con.newInstance("傻猫", 2);
        System.out.println(cat);
    }
}

3.获取类的成员变量

// 猫类
public class Cat {
    private String name;
    private int age;

    public Cat() {
    }

    //私有的有参构造
    private Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public class FieldDemo {

    @Test
    public void getFields() throws NoSuchFieldException, IllegalAccessException {
        // 1.获取类的字节码对象
        Class<Cat> clazz = Cat.class;

        // 2、获取已定义的所有变量
        Field[] fields = clazz.getDeclaredFields();

        // 3、遍历数组，验证
        for (Field field : fields) {
            System.out.println(field.getName() + "-->" + field.getType());
        }

        System.out.println("------------------------------------");

        // 4、获取指定的变量
        Field name = clazz.getDeclaredField("name");
        System.out.println(name.getName() + "-->" + name.getType());

        System.out.println("------------------------------------");

        // 5、赋值
        Cat cat = new Cat();
        //取消访问权限限制（即使private修饰，也可以使用）（设置为true，表示禁止检查访问控制） 【暴力反射】
        name.setAccessible(true);
        name.set(cat, "笨猫");
        System.out.println(cat);

        System.out.println("------------------------------------");

        // 6、取值
        String s = (String) name.get(cat);
        System.out.println(s);
    }
}

4.获取类的成员方法

// 猫类
public class Cat {
    private String name;
    private int age;

    public Cat() {
    }

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

    public void run() {
        System.out.println("猫跑得飞快");
    }

    private void eat(String food) {
        System.out.println("猫喜欢吃" + food);
    }

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

public class MethodDemo {

    @Test
    public void testMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 1、获取类的字节码对象
        Class<Cat> clazz = Cat.class;

        // 2、获取所有已定义的方法
        Method[] methods = clazz.getDeclaredMethods();

        // 3、遍历数组，打印得到每个方法的名字、参数个数、返回值类型
        for (Method method : methods) {
            System.out.println(method.getName() + "-->" + method.getParameterCount() + "-->" + method.getReturnType());
        }

        // 4.1 获取指定的方法，并执行该方法
        Method run = clazz.getDeclaredMethod("run");
        Cat cat = new Cat();
        run.invoke(cat);

        // 4.2 获取指定的方法，括号里有参数，并执行该方法
        Method eat = clazz.getDeclaredMethod("eat", String.class);
        //取消访问权限限制（即使private修饰，也可以使用）（设置为true，表示禁止检查访问控制） 【暴力反射】
        eat.setAccessible(true);
        eat.invoke(cat, "猫条");
    }
}