Java 反射详解

一、了解反射

1.1、什么是反射：

        在运行状态中，获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法，这种动态获取的信息以及动态调用对象的方法的功能就称为java反射机制。

1.2、反射机制的用途？

        1、通过反射机制访问java对象的属性、方法、构造方法（包括私有）等。

        2、运行时动态加载需要的加载的对象。         

        3、反编译         

1.3、反射优缺点

        1、优点：灵活性高，利用反射能在程序运行时获得类的各种信息，更加容易实现面向对象。

        2、缺点：效率较低，反射会消耗一定的系统资源，且反射用于字段和方法接入时要远慢于直接代码；反射调用方法时可以忽略权限检查，可能会破坏封装性而导致安全问题。

二、反射基本方法

2.1、获取Class类对象

        1、Class c1 = Class.forName("全限定类名");　　//通过Class类中的静态方法forName。

        2、Class c2  = Student.class;　　　　//当类被加载成.class文件时，获取

        3、Class c3 = s.getClass();　　　　//通过类的实例获取

public class Student {
    private String name;
    int age;

    public Student() {
        System.out.println("公共无参构造方法running");
    }

    private Student(String name, int age) {

        this.name = name;
        this.age = age;
        System.out.println("私有有参构造方法running");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void method1(){
        System.out.println("method1被调用");
    }
    private void method2(){
        System.out.println("method2被调用");
    }
}

//通过Class类中的静态方法forName。
        Class c1 = Class.forName("day28.Student");

        //当类被加载成.class文件时，获取
        Class c2 = Student.class;

        //通过类的实例获取
        Student s = new Student();
        Class c3 = s.getClass();
        
        //结果为true
        System.out.println(c1==c2&&c2==c3);

上面这段代码用了三种方法获取Class对象，这里推荐使用第一种方式，这是最常用的一种方式

2.2获取构造方法对象

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor<T> getConstructor(Class<?>... parameterTypes)	返回单个公共构造方法对象
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)	返回单个构造方法对象

2.2.1Constructor类用于创建对象的方法

方法名	说明
T newInstance(Object...initargs)	根据指定的构造方法创建对象

//通过Class类中的静态方法forName。
        Class c = Class.forName("day28.Student");

        //返回所有公共构造方法对象的数组
        Constructor[] cons1 = c.getConstructors();
        //输出获取到的所有公共构造方法
        for (Constructor con:cons1
             ) {
            System.out.println(con);
        }//输出结果：public day28.Student()


        //返回单个公共构造方法对象
        Constructor con1 = c.getConstructor();
        //输出结果：public day28.Student()
        System.out.println(con1);

        //返回所有构造方法对象的数组
        Constructor[] cons2 = c.getDeclaredConstructors();
        //输出获取到的所有构造方法
        for (Constructor con:cons2
        ) {
            System.out.println(con);
        }//输出结果：public day28.Student()


        //返回单个构造方法对象,通过设置方法中的参数来明确获取的是哪一个构造方法

        //返回无参构造方法对象
        //输出结果：public day28.Student()
        Constructor con2 = c.getDeclaredConstructor();
        System.out.println(con2);

        //返回有参构造方法
        //输出结果：private day28.Student(java.lang.String,int)
        Constructor con3 = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(con3);

        //根据指定的构造方法创建对象
        //根据无参构造方法创建对象，无参构造方法被调用，控制台输出：公共无参构造方法running
        Object obj = con1.newInstance();

代码运行到上面是没有问题的，但是通过Student类中的私有构造方法创建对象时

        //根据无参构造方法创建对象，有参构造方法被调用
        Object obj2 = con3.newInstance("Uzi",24);

Exception in thread "main" java.lang.IllegalAccessException: Class day28.Test05 can not access a member of class day28.Student with modifiers "private"

控制台输出了错误信息，(O_o)??

查看一下Student类里的构造方法，原来是因为这里的有参构造方法是私有的

    private Student(String name, int age) {

        this.name = name;
        this.age = age;
        System.out.println("私有有参构造方法running");
    }

咋整？难道就不能用这个构造方法了吗？of course not！

这里我们就可以回顾一下在介绍反射的优缺点时有这样一条：

反射调用方法时可以忽略权限检查，可能会破坏封装性而导致安全问题

通过反射的setAccessible()方法，并将参数设置为true就可以取消访问检查

//暴力反射，取消访问检查
        con3.setAccessible(true);

        //根据无参构造方法创建对象，有参构造方法被调用
        //控制台输出：私有有参构造方法running
        Object obj2 = con3.newInstance("Uzi",24);

2.3获取成员变量对象

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

2.3.1Field类用于给成员变量赋值的方法

方法名	说明
void set(Object obj,Object value)	给obj对象的成员变量赋值为value

        Class c = Class.forName("day28.Student");
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        //返回所有公共成员变量对象的数组
        Field[] f1 = c.getFields();

        //返回单个公共成员变量对象,方法参数为需要获取的变量名
        Field f2 = c.getField("age");
        //通过set方法对成员变量赋值
        f2.set(obj,24);

        //返回所有成员变量对象的数组
        Field[] f3 = c.getDeclaredFields();

        //返回单个成员变量对象,方法参数为需要获取的变量名
        //name属性为私有，通过set方法对成员变量赋值会无法访问
        //所以这里也要通过 暴力反射取消访问检查
        Field f4 = c.getDeclaredField("name");
        f4.setAccessible(true);
        f4.set(obj,"Uzi");

2.4获取成员方法对象

Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>... parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes)	返回单个成员方法对象

2.4.1Method类用于执行方法的方法

方法名	说明
Object invoke(Object obj,Object... args)	调用obj对象的成员方法，参数是args,返回值是Object类型

        Class c = Class.forName("day28.Student");
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        //返回所有公共成员方法对象的数组，包括继承的
        Method[] m1 = c.getMethods();

        //返回单个公共成员方法对象,方法参数为要获取的成员方法名
        Method m2 = c.getMethod("method1");
        //invoke方法，调用obj对象的成员方法，参数是args,返回值是Object类型
        //输出结果为：method1被调用
        m2.invoke(obj);

        //返回所有成员方法对象的数组，不包括继承的
        Method[] m3 = c.getDeclaredMethods();

        //返回单个成员方法对象,method2为私有方法，调用暴力反射
        Method m4 = c.getDeclaredMethod("method2");
        m4.setAccessible(true);
        //输出结果为：method2被调用
        m4.invoke(obj);

三、总结

        反射是Java中的特殊机制，它为程序带来了极大的灵活性及方便性，但反射也有缺点，它会降低代码的操作效率，会破坏安全性等等，总之，反射是一把双刃剑，我们只有熟练掌握Java反射的优缺点，才能妥善使用Java反射这一利器，为我们的编程扫清障碍而不至于影响到我们的程序本身。

拜里个拜~~~