【Java编程思想笔记】反射

文章参考：学习网站 how2java.cn

                           参考博客：（敬业的小码哥）https://blog.csdn.net/sinat_38259539/article/details/71799078

                                             （青色的画轴）https://www.cnblogs.com/yrstudy/p/6500982.html

                                             （chris.wu）https://www.cnblogs.com/buoge/p/9285142.html

1.反射的概述

       JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

       Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public、static等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。

 

2.为什么要用反射

        Java中编译类型有两种：

          （1）静态编译：在编译时确定类型，绑定对象，即通过

                                     在你敲代码的时候，就已经确定你要用的是哪个类的对象，new一个出来，使用

          （2）动态编译：运行时确定类型，绑定对象。动态编译最大限度地发挥了Java的灵活性，体现了多态的应用，可以减低类之间的耦合性。

                                      在你运行之前，你只知道你要用的类的名称，而不知道其具体有哪些属性，哪些方法，却可以在运行后操作它

         因此，Reflection可以在运行时加载、探知、使用编译期间完全未知的classes。即Java程序可以加载一个运行时才得知名称的class，获取其完整构造，并生成其对象实体、或对其fields设值、或唤起其methods。

 

       例如：  我们要创造两个类似的类的对象

        传统方法：

interface fruit{
    public abstract void eat();
}

class Apple implements fruit{

    @Override
    public void eat() {
        System.out.println("eat Apple");
    }
}

class Orange implements fruit{

    @Override
    public void eat() {
        System.out.println("eat Orange");
    }
}

class Factory{
    public static fruit getInstance(String fname){
        fruit f = null;
        if(fname.equals("Apple"))
            f = new Apple();
        
        if(fname.equals("Orange"))
            f = new Orange();
        
        return f;
    }
}

因此，当我们有了更多水果时，就需要重写工厂类，来添加更多选择，这不仅是个重复的工作，且代码的耦合度很高。

 

           反射机制：

class Factory{
    public static fruit getInstance(String fname){
        fruit f = null;
        try{
            f=(fruit)Class.forName(fname).newInstance();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
        return f;
    }
}

 而使用了反射机制的工厂类，则可以无需修改代码，只要你实现了一个类，应用了fruit接口，就可以用这个工厂类创造水果（实例）。

 

实际上，反射可以做的还有很多，这只是冰山一角。例如在Spring框架中的依赖注入，反转控制等。反射有着十分强大的功能。熟练的使用可以实现非常丰富的功能。

 

3.怎么用反射   

实现Java反射机制的类都位于java.lang.reflect包中：

1、Class类：代表一个类

2、Field类：代表类的成员变量（类的属性）

3、Method类：代表类的方法

4、Constructor类：代表类的构造方法

5、Array类：提供了动态创建数组，以及访问数组的元素的静态方法

 

   （1）Class类： 类对象，当获取到一个类对象后，你就能够进一步获取这个类的更多信息

             获取类对象的三种方法：forName() ， ClassName.class  ， instance.getClass()   （ClassName指类名称，instance是指一个对象实例）

        String className = "Hero";

        //获取类对象的三种方法
        try{
            Class hClass1 = Class.forName(className);
            Class hClass2 = Hero.class;
            Class hClass3 = new Hero().getClass();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }

             当我们获取到类对象时，会导致类中的属性被初始化，例如在类中加一个静态代码块，看在获取类时会不会初始化

public class Person {

    private String name;
    private int id;

    static {
        System.out.println("初始化Person类");
    }
}

 

       （2）Constructor类：代表类的构造方法  我们可以用它来获取类的对象

        String className = "ReflectTest.Person";

        //通过Constructor获取一个对象
        try{
            Class hClass1 = Class.forName(className);
            Constructor c = hClass1.getConstructor();
            Person p = (Person)c.newInstance();
            p.setName("bilibili");
            System.out.println(p);
        }catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e){
            e.printStackTrace();
        }

         

        （3）Field类：代表类的成员变量（类的属性）   通过它获取类的变量

try{
            Person p = new Person();
            p.setName("lala");
            p.setId(15);
            p.age=15;

            Class pClass = p.getClass();
            Field f1 = pClass.getDeclaredField("age");

            f1.set(p,15);

            System.out.println(p);

        }catch (NoSuchFieldException | IllegalAccessException e){
            e.printStackTrace();
        }

           这里的age是public的，因此可以直接修改，而对于private修饰的属性，应该如下操作：

            Class pClass = p.getClass();
            
            //获取Person类的所有属性
            Field[] fields = pClass.getDeclaredFields();
            
            //对所有属性设置访问权限
            AccessibleObject.setAccessible(fields,true);

            //对单个属性设置访问权限
            Field f1 = pClass.getDeclaredField("name");
            f1.setAccessible(true);
            
            f1.set(p,"Baolan");

 

        （4）Method类：代表类的方法   通过它可以调用类中的方法

           为此我先在Person类中添加了两个方法

    public void run(){
        System.out.println(name+" is Running");
    }

    private void feel(String f){
        System.out.println(name+" is Felling "+f);
    }

          然后我们来通过反射调用

            Class pClass = p.getClass();

            //获取类中叫做run的方法
            Method mrun = pClass.getMethod("run");

            mrun.invoke(p);

         同样的，对于私有的方法，要设置访问权限，同时要注意feel是一个有参数的方法，需要在调用时导入参数

            Class pClass = p.getClass();

            //获取类中叫做feel的方法，并导入其参数的类型
            Method mfeel = pClass.getDeclaredMethod("feel",String.class);
            mfeel.setAccessible(true);
 
            //在使用feel方法时，加入feel方法需要的参数"Good"
            mfeel.invoke(p,"Good");

 

4.测试用例

         这里我们用配置文件来进行两种方法的切换调用

首先我们定义两个类，实现两个不同的方法

public class DoSomething {
    public void doSome1(){
        System.out.println("Do Great");
    }
}

public class DoSomething2 {
    public void doSome2(){
        System.out.println("Do Bad");
    }
}

然后将其中一个的信息保存到一个txt文件中

class=ReflectTest.DoSomething
method=doSome1

然后通过配置文件获取其内容，调用文件中保存的方法

        try{
            //从保存类名称和方法名称的文件中获取信息
            File configfile = new File("D:\\IDEAworkspace\\JavaBasick\\methodtxt.txt");
            Properties config = new Properties();
            config.load(new FileInputStream(configfile));
            String className = (String)config.get("class");
            String methodName = (String)config.get("method");

            //根据类名称获取类对象
            Class dclass = Class.forName(className);
            //根据方法名称获取方法
            Method method = dclass.getMethod(methodName);
            //获取构造器
            Constructor c = dclass.getConstructor();
            //实例化
            Object dosomething = c.newInstance();
            //调用指定方法
            method.invoke(dosomething);
        }catch (Exception e){
            e.printStackTrace();
        }

可以看到，在上面的代码中，我们并没有指出要用什么类，以及什么方法，这些都是只保存在methodtxt文件中的

因此只要我们修改文件中的内容，就可以调用不同类的不同方法了，如

class=ReflectTest.DoSomething2
method=doSome2