Java学习笔记----反射

什么是反射？

既然有一“反”字，那么必有正。
何谓正？一般我们想要使用一个类，会先知道他的名字，是做什么的，然后实例化得到一个对象，对类对象进行操作。

//正，知道类是什么类，创建类对象，使用对象的方法
        Man man = new Man();
        man.setName("小红");
        System.out.println("这个人的名字叫： " + man.getName());

那么反，就是不知道是什么类，仅仅通过字符串在运行时获取类的完整构造，并调用相应的方法

//获取类的class对象实例
            Class cls = Class.forName("com.test.Man");
            //得到类中的setName方法
            Method setName  = cls.getMethod("setName",String.class);
            //根据类对象的实例获取constructor对象
            Constructor manConstructor = cls.getConstructor();
            //根据constructor类的newInstance()方法获取反射类对象
            Object manObject = manConstructor.newInstance();
            //利用invoke方法调用类中的方法
            setName.invoke(manObject,"小明");
            Method getName = cls.getMethod("getName");
            System.out.println("人的名字叫： " + getName.invoke(manObject) );

以上完整示例代码：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Man {
    private  String name;
    //        public Man(String name){
//            this.name = name;
//        }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public static void main(String[] args) {
        //正，知道类是什么类，创建类对象，使用对象的方法
        Man man = new Man();
        man.setName("小红");
        System.out.println("这个人的名字叫： " + man.getName());

        //反，不知道类名
        try {
            //获取类的class对象实例
            Class cls = Class.forName("com.test.Man");
            //得到类中的setName方法
            Method setName  = cls.getMethod("setName",String.class);
            //根据类对象的实例获取constructor对象
            Constructor manConstructor = cls.getConstructor();
            //根据constructor类的newInstance()方法获取反射类对象
            Object manObject = manConstructor.newInstance();
            //利用invoke方法调用类中的方法
            setName.invoke(manObject,"小明");
            Method getName = cls.getMethod("getName");
            System.out.println("人的名字叫： " + getName.invoke(manObject) );
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

如何实现反射 ？

1 首先要得到这个类的class对象
有三种方式：

1. class.forName(“类的全路径名”)
   Class cls = class.forName(“类的全路径名”)
2. .class方法（适合在编译前就知道class）
   Class cls = 类名.class;
3. 使用类对象的getClass()方法
   String s = new String(“hello world”);
   Class cls = s.getClass();

2 通过反射创建类对象

1. 通过class对象的newInstance()方法
   Class cls = Man.class;
   Man man = (Man) cls.newInstance();
2. 通过constructor的newInstance()方法
   Class cls = Man.class;
   Constructor manConstructor = cls.getConstructor();
   Man man = (Man)maxConstructor.newInsatance();

3 通过反射获取类的属性、方法和构造器
1 Class 对象的getFields()可方法以获取类的属性，但是无法获取私有属性,Class 对象的 getDeclaredFields() 方法则可以获取包括私有属性在内的所有属性
Field[] fields = cls.getFields();//无法获取私有属性
Field[] fields = cls.getDeclaredFields();//可获得所有属性

为什么要有反射？

反射主要是为了实现动态性，可以在运行时确定类型，绑定对象。在运行时使用，加载在编译期间完全未知的类，极大的增加了java的灵活性。

如果现在两个程序员合作写代码，A程序员要用B程序员的类，但是B程序员没有写好，那么A的代码能不能完成编译呢？是不能的。但是反射就可以使得A 程序员的代码完成编译。

反射是否破坏了程序的封装性？

封装、继承，多态是面向对象的三大特点。

封装性是指对外隐藏对象的属性和实现细节，仅对外提供公共的访问方式

但上面我们说了，可以通过反射得到类的所有属性和方法，不管类中的属性和方法被什么修饰，在反射之后都是一丝不挂。那么我们封装这么属性的意义在哪里呢？

其实没有破坏，因为呢，我们通过反射，得到了一个类，然后我们自然而然得到了类里面的所有属性和方法，但我只是得到了，并没有在外部对这个private的成员进行访问，所以本质上是不破坏的。

而且类中被修饰为私有方法的，都是服务于类里面的共有方法的，并且依附于其他公有方法而存在。就算是用户拿到了私有的属性的修改权限，没得啥意义。