反射

反射：一个类有多个组成部分。例如：成员变量，方法，构造方法等。反射就是加载类，并解剖出类的各个组成部分。反射多用在框架的制作上。

加载类：Java中有一个Class类用于代表某一个类的字节码，它提供加载某个类字节码的方法：forName()。forName()方法用于加载某个类的字节码到内存中，并使用class对象进行封装

下面是加载类的三种方法

        //加载类的方法一(这个方法里面类的路径必须是带包的完整路径)
        try {
            Class c1 = Class.forName("Test/src/day4025/Person");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //加载类的方法二
        Class c2 = new Person().getClass();
        
        //加载类的方法三
        Class c3 = Person.class;

解剖类：Class对象提供了一系列的解剖方法，分别用于解剖出构造方法，方法和成员变量。解剖出的成员分别使用Constructor，Method，Field对象表示。

1.下面先给出加载类，然后解剖出构造方法对象产生对象的例子

首先是Person类

public class Person {
    
    public String name = "??";
    
    public Person(){
        System.out.println("Person");
    }
    
    public Person(String name){
        System.out.println(name);
    }
    
    public Person(String name, int age){
        System.out.println(name + "," + age);
    }
    
    private Person(int age){
        System.out.println(age);
    }
    
}

然后是Junit测试演示

Class c1 = null;
    
    @Before
    public void testBefore() throws Exception{
        c1 = Class.forName("day4025.Person");
    }
    
    @Test
    //获得public Person()构造函数
    public void test1() throws ClassNotFoundException, Exception, Exception{
        
        /*//加载类
        Class c1 = Class.forName("day4025.Person");*/
        //获得构造方法对象
        Constructor cs = c1.getConstructor(null);
        //利用获得的构造方法对象来生成对象
        Person p1 = (Person)cs.newInstance(null);
        System.out.println(p1.name);
        System.out.println();
    }
    
    @Test
    //获得public Person(String name)构造函数
    public void test2() throws Exception{
        /*//加载类
        Class c1 = Class.forName("day4025.Person");*/
        //获得构造方法对象
        Constructor cs = c1.getConstructor(String.class);
        //利用获得的构造方法对象来生成对象
        Person p = (Person)cs.newInstance("hello");
        System.out.println(p.name);
        System.out.println();
    }
    
    @Test
    //获得public Person(String name, int age)构造函数对象
    public void test3() throws Exception{
        /*//加载类
        Class c1 = Class.forName("day4025.Person");*/
        //获得构造方法对象
        Constructor cs = c1.getConstructor(String.class,int.class);
        //利用获得的构造方法对象来生成对象
        Person p = (Person) cs.newInstance("hello",666);
        System.out.println(p.name);
        System.out.println();
    }
    
    @Test
    //获得private Person(int age)构造函数对象
    public void test4() throws Exception{
        /*// 加载类
        Class c1 = Class.forName("day4025.Person");*/
        // 获得构造方法对象getConstructor只能调用public，想要调用私有的要用getDeclaredConstructor
        Constructor cs = c1.getDeclaredConstructor(int.class);
        //私有的构造函数在外部是不能访问的但是我们可以（暴力反射），强行进行访问
        cs.setAccessible(true);
        // 利用获得的构造方法对象来生成对象
        Person p = (Person) cs.newInstance(666);
        System.out.println(p.name);
        System.out.println();
        
    }
    
    @Test
    //创建对象的另外一种方法(效果和test1一样，不过Java帮我们写好了，直接调用即可)
    public void test5() throws Exception{
        
        /*//加载类
        Class c1 = Class.forName("day4025.Person");*/
        Person p = (Person)c1.newInstance();
        
    }

可以看出当我们加载类后，可以解剖出构造方法对象(根据构造函数的参数类型和个数确定出解剖出的是哪一个构造函数的对象)，然后产生Person对象。

上列代码结果如下

Person
??

hello
??

hello,666
??

666
??

Person

2.解剖方法对象，然后使用方法

首先是Animal类

public class Animal {
    
    public void eat(){
        System.out.println("eat");
    }
    
    public int sum(int a,int b){
        return a + b;
    }
    
    public static void happly(){
        System.out.println("happly");
    }
    
    private void play(){
        System.out.println("play");
    }
    
}

然后是Junit测试演示

public class Demo5 {
    
    Class c = null;
    Animal a = new Animal();
    
    @Before
    public void testBefore() throws Exception{
        c = Class.forName("day4025.Animal");
    }
    
    @Test
    //测试方法 public void eat()
    public void test1() throws Exception{
        
        Method method = c.getMethod("eat", null);
        method.invoke(a, null);
        
    }
    
    @Test
    //测试方法 public int sum(int a,int b)
    public void test2() throws Exception{
        
        Method method = c.getMethod("sum", int.class,int.class);
        int x = (int) method.invoke(a, 1, 2);
        System.out.println(x);
        
    }
    
    @Test
    //测试方法 public static void happly()
    public void test3() throws Exception{
        
        Method method = c.getMethod("happly", null);
        method.invoke(null, null);
        
    }
    
    @Test
    //测试方法 private void play()
    public void test4() throws Exception{
        
        Method method = c.getDeclaredMethod("play", null);
        //暴力放射使private的方法强行被访问
        method.setAccessible(true);
        method.invoke(a, null);
        
    }
    
    
}

解剖构造函数和普通函数的区别，一：是我们在获得普通方法对象的时候，还需要写入方法名，构造方法不需要，因为构造方法名字一样，普通方法对象获取写入方法名，帮助我们区分不同的方法。二：解剖出普通函数后，要运行函数要需要指定对象，是运行什么对象的方法。

运行结果

eat
3
happly
play

3.main方法的反射

先贴main函数代码

    public static void main(String[] args) {
        System.out.println("main");
    }

然后是Junit测试演示

    @Test
    //测试方法 public static void main(String[] args)
    public void test5() throws Exception{
        
        Method method = c.getDeclaredMethod("main", String[].class);
        method.invoke(null, (Object)new String[]{"1","2","3"});
        method.invoke(null, new Object[]{new String[]{"1","2","3"}});
        
    }

结果如下

main
main

运行成功了，但是代码和我们上面写的不一样，按照上面写的话我们应该这样写

method.invoke(null, new String[]{"1","2","3"});

但是这样写报错了，说参数数量错误，为什么会这样呢。

因为在Java1.4我们还没有可变参数，我们是用数组来储存方法的多个参数的，所以这里Java会以为我们的main函数有3个String类型的参数，其实只有一个String类型数组的参数，所以会报参数数量错误。（Java1.5要兼容Java1.4这就是为什么出现这个错误的原因）

解决方法 一.我们可以把这个String数组放在Object数组里面，当Java把Object数组拆开后，就会得到我们需要的String数组参数。

方法二.可以将数组包装成Object对象，Java就不会将它拆开。

4.解剖字段对象

测试的字段

    public int a = 10;
    public static int b = 20;
    private int c = 30;

Junit测试演示

    Class c = null;
    Animal b = new Animal();
    
    @Before
    public void testBefore() throws Exception{
        c = Class.forName("day4025.Animal");
    }

    @Test
    //测试 public int a = 10;
    public void test7() throws Exception{
        Field f = c.getField("a");
        int x = (int) f.get(b);
        System.out.println(x);
        f.set(b, 100);
        int y = (int) f.get(b);
        System.out.println(y);
    }
    
    @Test
    //测试 public static int b = 20;
    public void test8() throws Exception{
        
        Field f = c.getField("a");
        int x = (int) f.get(b);
        System.out.println(x);
        f.set(b, 200);
        int y = (int) f.get(b);
        System.out.println(y);
        
    }
    
    @Test
    //测试 private int d = 30;
    public void test9() throws Exception{
        
        Field f = c.getDeclaredField("d");
        f.setAccessible(true);
        int x = (int) f.get(b);
        System.out.println(x);
        f.set(b, 300);
        int y = (int) f.get(b);
        System.out.println(y);
    }