【JavaSE】反射

最新推荐文章于 2022-11-17 15:08:08 发布

刘减减

最新推荐文章于 2022-11-17 15:08:08 发布

阅读量242

点赞数

分类专栏： JavaSE语法文章标签： java 反射

本文链接：https://blog.csdn.net/weixin_44258092/article/details/126558618

版权

JavaSE语法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

5.1 反射第一步：拿到当前需要反射的类的Class对象

一、定义

Java的反射机制是在运行状态中，对于任意一个类，能够知道这个类的所有属性和方法；对于任意一个对象，能够调用它的任何方法和属性。既然能够拿到，那就能修改。这种动态获取信息并且动态调用对象方法的功能称为Java语言的反射机制。

二、意义

Java已经有了封装为什么还需要反射呢？

反射让类的开发人员通过外部类的全路径名称创建类，并使用这些类去实现一些扩展的功能。
发射让开发人员可以枚举出类的全部信息，包括构造函数、属性、方法，帮助开发者写出正确的代码。
测试时可以利用反射API访问类的私有成员，保证测试代码覆盖率。

三、用途

在第三方开发过程中，经常会遇到某个类的某个成员变量、方法是私有的，这时就可以利用Java的反射机制来获取所有的私有成员变量或者方法。
最重要的用途就是开发各种通用框架。比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

四、反射相关的类

4.1 分类

Class类：代表类的实体，在运行的Java应用程序中表示类和接口
Filed类：代表类的成员变量
Method类：代表类的方法
Constructor：代表类的构造方法

4.2 获得类相关的方法

Java文件被编译后，会生成.class字节码文件。字节码文件最终被加载到JVM的方法区，之后JVM就会将要使用的字节码文件解析成一个对象，这个对象就是java.lang.class,他存储在JVM的堆中。因此，当程序运行时，每个Java文件最终都变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以获得甚至去添加、改变这个类的属性和行为，使得这个类称为一个动态的类。

方法	用途
getClassLoader()	获得类的加载器
getDeclaredClasses()	返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)	根据类名返回类的对象
newInstance()	创建类的实例
getName()	获得类的完整路径名字

4.3 获得类属性相关的方法

方法	用途
getField(String name)	获得某个公有的属性对象
getFields()	获得所有公有的属性对象
getDeclaredField(String name)	获得某个属性对象
getDeclaredFields()	获得所有属性对象

4.4 获得类中构造器相关的方法

方法	用途
getConstructor(las...<?> parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	获得该类的所有公有构造方法
getDeclaredConstructor(lass... <?> parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

4.5 获得类中方法相关的方法

方法	用途
getMethod(String name, Clas...<?> parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class... <?> parameterTypes)-	获得该类某个方法
getDeclaredMethods()	获得该类所有方法

五、举例：获取Class对象

5.1 反射第一步：拿到当前需要反射的类的Class对象

获取方式有三种：

使用Class.forName("类的全路径名")，前提是已明确类的全路径名
使用.class方法。仅适用于在编译前已经明确要操作的Class
适用类对象的getClass()方法

结论1：一个类对应一个Class对象

结论2：Java中创建对象的方式有几种？

new、clone、newInstance()

Step1：写一个Student类

class Student {
    // 私有属性 name
    private String name = "lb";
    // 公有属性 age
    public int age = 18;

    // 不带参数的构造方法
    public Student() {
        System.out.println("Student()");
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat() {
        System.out.println("eat");
    }

    public void sleep() {
        System.out.println("sleep");
    }

    private void function(String str) {
        System.out.println(str);
    }

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

step2：获取Student的类对象

    public static void main(String[] args) {
        // 拿到Class对象
        Class<?> c1 = null;
        try {
            c1 = Class.forName("demo1.Student");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?> c2 = Student.class;
        Student student = new Student();
        Class<?> c3 = student.getClass();
        System.out.println(c1==c2);  // true
        System.out.println(c2 == c3); // true
        System.out.println(c1==c3);  // true
    }

5.2 应用反射，调用构造方法

    public static void reflectNewInstance(){
        Class<?> c1 = null;
        try {
            c1 = Class.forName("demo1.Student");
            // 调用的是公有的不带参数的构造方法
            Student student = (Student) c1.newInstance();
            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

5.3 应用反射，调用私有的构造方法

    // 反射私有的构造方法，屏蔽内容为
    public static void reflectPrivateConstructor(){
        Class<?> c1 = null;
        try {
            c1 = Class.forName("demo1.Student");
            // 注意传入的参数
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class);
            // 修改为true可修改访问权限
            constructor.setAccessible(true);
            Student student = (Student) constructor.newInstance("lsjhjs",18);
            System.out.println(student);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

5.4 应用反射，调用私有的属性

// 获取私有属性
    public static void reflectPrivateFiled() {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("demo1.Student");
            Field field = c1.getDeclaredField("name");
            field.setAccessible(true);
            // 因为字段是属于对象的，所以得先有一个student对象
            Student student = (Student)c1.newInstance();
            // 修改student这个对象的filed这个字段，把值修改为了asd
            field.set(student,"asd");
            System.out.println(student);
            String str = (String)field.get(student);
            System.out.println(str);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

5.5 应用反射，调用私有的方法

public static void reflectPrivateMethod(){
        try {
            Class c1 = Class.forName("demo1.Student");
            Method method = c1.getDeclaredMethod("function",String.class);
            method.setAccessible(true);
            Student student = (Student)c1.newInstance();
            method.invoke(student,"function的参数");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

六、反射的优缺点

优点

对于任意一个类，能够知道这个类的所有属性和方法，对于任意一个类，能够调用它的任意一个方法
增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
反射已经应用在很多框架中，如Spring、SpringMVC、MyBatis

缺点

导致程序效率降低。
反射技术绕过了源代码的技术，因此会带来维护问题。反射代码比相应的直接代码更复杂。

刘减减

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JavaSE】反射

Java的反射机制是在运行状态中，对于一个类，能够知道这个类的所有属性和方法；对于任意一个对象，能够调用它的任何方法和属性。与反射相关的类有四种，Class、Filed、Method和Constructor。需要掌握这四个类的常用方法。反射可以提高代码的灵活性和扩展性，但是降低了程序的效率。...
复制链接

扫一扫