java--反射机制

Reflection是java被视为动态语言的关键，反射机制允许程序在执行期间借助于ReflectionAPI获得任何类的内部信息，并能直接操作任何对象的内部属性及方法。

Class c = class.forName("java.lang.String")

加载完类之后，在堆内存的方法区就产生了一个class类型的对象（一个类只有一个class类型的对象），这个对象就包括了完整的类的结构信息。我们可以通过这个对象看到类的结构，这个对象就像一面镜子，通过这个镜子看到类的结构，所以我们称之为反射。

java反射机制提供的一些功能：

在运行时判断一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有的成员变量和方法。

在运行时获取泛型信息，

在运行时任意调用一个对象的成员变量和方法

在运行时处理注解

生成动态代理

获取Class类的方式

1.已知具体的类，通过类的class属性获取,该方法安全可靠，程序性能高

Class c4 = Student.class;

2.已知某个类的实例化对象也可以通过getClass()方法获取class对象

    Student student = new Student();
    Class c5 = student.getClass();

3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，但是得抛异常，因为这样不确定这个类是否真实存在，可能返回空值。

Class c1 = Class.forName("com.yf.pojo.Student");

4.基本内置类型的包装类都有一个type属性

Class<Integer> type = Integer.TYPE;

5.获得父类类型

Class c6 = c2.getSuperclass();

哪些类可以有Class对象？

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

interface：接口

数组

枚举

annotation：注解@interface

primitive type：基本数据类型

void

只要是一个类，得到的class对象就是一个

什么时候会发生类的初始化：

类主动引用的时候就会发生类的初始化

1.虚拟机启动的时候，先初始化main方法所在的类

2.new一个类的对象

3.调用静态成员变量（除了final常量）和静态方法

4.使用反射

5.当初始化一个类时，如果父类没有被初始化，则会先初始化父类

不会被加载的情况

1.当访问一个静态域的时候，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。

2.通过数组定义类引用，不会触发类的初始化（因为数组只是声明了一片空间）

3.引用常量不会触发类的初始化（常量在链接阶段就存入调用类的常量池了）

获取运行时类的完整结构：

Field，Method，Constructor，Superclass，Interface，Annotation

Class cl1 = Class.forName("com.yf.pojo.Student");
        //获得类的名字 包名加类名
        System.out.println(cl1.getName());
        //获得类名
        System.out.println(cl1.getSimpleName());
        //获得类的public属性
        Field[] fields = cl1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //获得类的全部属性
        Field[] declaredFields = cl1.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //获得类的单一属性
        Field name = cl1.getDeclaredField("name");
        System.out.println(name);

        //获得本类及其父类的全部public方法
        Method[] methods = cl1.getMethods();
        for (Method method : methods) {
            System.out.println("public:" + method);
        }
        //获得本类的所有方法
        Method[] declaredMethods = cl1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        //获得指定方法
        System.out.println(cl1.getMethod("getName", null));
        System.out.println(cl1.getMethod("setName", String.class));

        //获得全部构造器
        Constructor[] declaredConstructors = cl1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        //获得public构造器
        Constructor[] constructors = cl1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //获得指定构造器
        Constructor constructor = cl1.getConstructor(null);
        System.out.println(constructor);

动态的创建对象使用反射的方法、属性、构造器

Class c1 = Class.forName("com.yf.pojo.Student");
        Student student = (Student) c1.newInstance();//实际上就是调用了无参构造
        System.out.println(student);
        //通过有参构造来创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(int.class, String.class);
        Student yf = (Student) declaredConstructor.newInstance(20, "yf");
        System.out.println(yf);
        //通过反射来使用方法
        Method setName = c1.getMethod("setName", String.class);
        setName.invoke(student,"yfyf");
        System.out.println(student.getName());
        //通过反射来使用属性
        Field name = c1.getDeclaredField("age");
        //不能直接操作私有属性，通过关闭程序的安全监测才可以,默认为开启，值为false
        System.out.println(name.isAccessible());
        name.setAccessible(true);

        name.set(student,22);
        System.out.println(student.getAge());

setAccessible（）

Method和Filed、Construction对象都有setAccessible方法

setAccessible方法的作用是启用和禁用访问安全检查的开关。

参数值为true则指示反射的对象在使用时应该取消java语言访问检查。

-提高反射的效率。如果代码中必须使用反射，而该句代码需要频繁的调用，那么设置为true

-使得原本无法访问的私有成员也可以访问。

参数值为false则指示反射的对象应该实施java语言访问检查。

关于setAccessible（）的性能测试：

public class Test05 {
    public static void test01(){
        Student student = new Student();
        long startTime  = System.currentTimeMillis();
        for(int i=0;i<1000000000;i++){
            student.getName();
        }
        long endTime  = System.currentTimeMillis();
        System.out.println("普通方式"+(endTime-startTime)+"ms");
    }
    public static void test02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class c1 = Class.forName("com.yf.pojo.Student");
        Method getName = c1.getMethod("getName",null);

        long startTime  = System.currentTimeMillis();
        for(int i=0;i<1000000000;i++){
            getName.invoke(student,null);
        }
        long endTime  = System.currentTimeMillis();
        System.out.println("反射"+(endTime-startTime)+"ms");
    }
    public static void test03() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class c1 = Class.forName("com.yf.pojo.Student");
        Method getName = c1.getMethod("getName",null);
        getName.setAccessible(true);
        long startTime  = System.currentTimeMillis();
        for(int i=0;i<1000000000;i++){
            getName.invoke(student,null);
        }
        long endTime  = System.currentTimeMillis();
        System.out.println("反射关闭安全检查机制"+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test01();
        test02();
        test03();


    }
}

在反射中关闭安全检查确实可以提高性能。