反射

最新推荐文章于 2022-06-20 13:06:44 发布

银河猎户悬臂

最新推荐文章于 2022-06-20 13:06:44 发布

阅读量151

点赞数 1

分类专栏： Java基础文章标签： java 反射 class 类

本文链接：https://blog.csdn.net/weixin_40617815/article/details/109467211

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1 反射的概念

反射是java提供的一个重要功能，可以在运行时检查类、接口、方法和变量等信息，无需知道类的名字，方法名等。还可以在运行时实例化新对象，调用方法以及设置和获取变量值。

反射的好处：

（1）反射实现了：“在运行时才知道要操作的类是什么”，并且可以在运行时获取类的完整构造，以及调用方法。

（2）解耦，提高程序的可扩展性

程序运行时，会将class文件加载进内存并对该类进行“解剖”（获取构造、属性、方法等），而解剖的途径就是“该类的class文件对象”，该class对象用来将我们所需要的构造、属性、方法等提取出来，如下图所示：

2 获取类的Class对象

反射关键对象：class文件对象
获取Student类的Class文件对象的三种方法：
（1）对象的getClass()方法获取（getClass()方法定义在Object类中）
（2）使用类的静态属性class获取
（3）（最常用，推荐）使用Class类的静态方法forName(全限定类名)获取，该方法的扩展性最好

下面以Student类为例，通过代码，演示该类的class对象的创建方式，以及通过“反射”来使用Student类的构造方法、成员属性、成员方法。最后，通过一个简单的案例，讲解“反射”是如何做到解耦，来提高程序的可扩展性的。

public class Student {
    /*static{
        System.out.println("静态代码块");
    }*/

    //字段
    private String name;
    private int age;

    //无参、有参构造函数
    public Student(){
    }
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法
    public void study(){
        System.out.println("学生在学习");
    }

    public void eat(String s,double d){
        System.out.println("带参数方法:"+s+"::"+d);
    }

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

/**
 * 反射关键对象：class文件对象
 * 获取Student类Class文件对象的三种方法：
 * 1、对象的getClass()方法获取 （getClass()方法定义在Object类中）
 * 2、使用类的静态属性class获取
 * 3、（最常用）使用class类的静态方法forName(全限定类名)获取，该方法的扩展性最好
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //1、对象的getClass()方法获取 （getClass()方法定义在Object类中）
        Student student = new Student();
        Class c1 = student.getClass();
        System.out.println(c1);

        //2、使用类的静态属性class获取
        Class c2 = Student.class;
        System.out.println(c2);

        //3、使用class类的静态方法forName()获取
        Class c3 = Class.forName("com.lmy.reflect.Student");
        System.out.println(c3);
    }
}

3 通过反射获取类的构造方法

3.1 获取无参构造

（1）完整的写法

public static void main(String[] args) throws Exception, Exception {
        //1、拿到该类的Class对象
        Class c = Class.forName("com.lmy.reflect.Student");
        //2、根据Class类对象中的方法getConstructor() 获取类中的无参构造，如果想获取其他有参构造，就传入参数列表
        Constructor constructor = c.getConstructor();
        //3、运行构造方法，创建对象
        Object object = constructor.newInstance(); //object对象就是Student对象
        System.out.println(object);

        //上面的这三行代码等同于如下的一行：
        Student student = new Student();
        System.out.println(student);
    }

（2）简略的写法（少写一行，但是有条件：被反射的类必须具有public权限的无参数构造）

/**
 反射获取Student类的无参构造方法并执行（减少一行代码）
 使用简单的方式，减少代码量（前提：被反射的类必须具有public权限的无参数构造）
 */

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("com.lmy.reflect.Student");
        //Class类中定义方法 Object newInstance() 运行无参构造，创建对象
        Object o = c.newInstance();
        System.out.println(o);
    }
}

3.2 获取带参构造

public static void main(String[] args) throws Exception {
        //获取Class类对象
        Class c = Class.forName("com.lmy.reflect.Student");
        //该对象的getConstructor方法获取构造：构造方法参数列表中，数据类型的Class文件对象作为参数)
        Constructor constructor = c.getConstructor(String.class, int.class);
        //创建对象
        Object object = constructor.newInstance("张三", 30);
        System.out.println(object);

        //上面的这三行代码等同于：
        Student student = new Student("张三",30);
        System.out.println(student);
    }

4 通过反射获取类的成员方法

3.1 获取无参成员方法

public static void main(String[] args) throws Exception {
        //获取Student类的Class对象c
        Class c = Class.forName("com.lmy.reflect.Student");
        //创建Student对象
        Object object = c.newInstance();
        //Class类方法getMethod(string 方法名，方法参数列表)获取指定的成员方法
        Method method = c.getMethod("study");
        //运行成员方法：Method类的对象：invoke(Object obj, Ovject...对象类型的可变参)第一个参数为本类的对象，因为我们调用的时类的非静态方法study()，所以需要对象支持
        method.invoke(object);

3.2 获取带参成员方法

public static void main(String[] args) throws Exception {
        //创建Student类的Class类对象
        Class c = Class.forName("com.lmy.reflect.Student");
        //创建一个Student对象
        Object object = c.newInstance();
        //获取eat方法getMethod("方法名字符串",参数类型的class对象...)
        Method eat = c.getMethod("eat", String.class, double.class);
        eat.invoke(object,"字符串",9.8);
    }

4 反射的好处

以普通的方式来创建对象，调用方法，就是我们常用的new关键字：编译器将.java文件编译成.class文件之后，普通方式创建的对象就不能再变了，我只能选择是运行还是不运行这个.class文件。
是不是感觉很僵硬？
假如现在我有个写好的程序已经放在了服务器上，每天供人家来访问，这时候Mysql数据库宕掉了，改用Oracle,这时候该怎么怎么办呢？
假如没有反射的话，我们是不是得修改代码，将Mysql驱动改为Oracle驱动，重新编译运行，再放到服务器上。很麻烦，还影响用户访问。
假如我们使用反射Class.forName()来加载驱动，只需要修改配置文件就可以动态加载这个类，
Class.forName()生成的结果在编译时是不可知的，只有在运行的时候才能加载这个类，
换句话说，此时我们是不需要将程序停下来，只需要修改配置文件里面的信息就可以了。
这样当有用户在浏览器访问这个网站时，都不会感觉到服务器程序程序发生了变化。

此段关于反射的好处节选于：https://www.cnblogs.com/bihanghang/p/9992237.html

5 简单的反射案例，实现程序可扩展

实现步骤
1、创建配置文件（一个文本，写键值对,后缀名一般是Properities，放在src目录下,src下的文件是源代码，
编译后是class文件，class文件和配置文件刚好是同步的,类加载器的getResourceAsStream()方法可以自动扫描读取）
2、通过类加载器，IO读取配置文件，读取文件中的键值对
3、键值存储在集合中Properities
4、集合中取到键值对，拿到类名和方法名
5、反射调用

 public static void main(String[] args) throws Exception {
        //Test的类加载器，必须先取到这个类的Class文件对象
        ClassLoader classLoader = Test.class.getClassLoader();
        //加载器获取字节输入流
        InputStream inputstream = classLoader.getResourceAsStream("config.properties");
        //流对象和集合关联使用
        Properties properties = new Properties();
        properties.load(inputstream);
        //集合方法：获取值
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");
        //反射获取这个类的class文件对象，创建对象，获取类方法，执行方法
        Class c = Class.forName(className);
        Object object = c.newInstance();
        Method teach = c.getMethod(methodName);
        teach.invoke(object);
    }

配置文件config.properities中的内容如下：

className=com.lmy.test.Teacher
methodName=teach

在程序运行时，才知道我们要使用的类到底是如下的哪个（通过配置文件指定）

public class Teacher {
    public void teach(){
        System.out.println("老师在上课");
    }
}

public class Student {
    public void study(){
        System.out.println("学生在学习");
    }
}

到现在为止：关于配置文件中所规定的类的方法的调用问题，已经用代码写好了。

但是“最后具体要使用的类，以及需要调用的方法”并没有“写死”到代码里，而是通过“配置文件”来体现：配置文件可以随意修改

当前我们调用的是Teacher类的teacher方法，一旦修改配置文件，我们就可以直接调用Student类的study方法，只需要修改配置而已（当然了，要保证所调用方法的参数类型是统一的，上面的例子是对于无参成员方法的调用）。

以上，通过简单的反射案例，实现了程序的可扩展。

银河猎户悬臂

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
反射

1 反射的概念反射是java提供的一个重要功能，可以在运行时检查类、接口、方法和变量等信息，无需知道类的名字，方法名等。还可以在运行时实例化新对象，调用方法以及设置和获取变量值。反射的好处：（1）反射实现了：“在运行时才知道要操作的类是什么”，并且可以在运行时获取类的完整构造，以及调用方法。（2）解耦，提高程序的可扩展性程序运行时，会将class文件加载进内存并对该类进行“解剖”（获取构造、属性、方法等），而解剖的途径就是“该类的class文件对象”，该class对象用来将我们所需要的构
复制链接

扫一扫