反射 | 如雨时光

静态语言 VS 动态语言

动态语言：
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。
通俗讲就是：在运行时代码可以根据某些条件改变自身结构

主要动态语言有：Object-C、C#、JavaScript、PHP、Python等。

静态语言：

与动态语言相对，运行时结构不可以改变。如Java、C、C++。

Java不是动态语言，但是Java可以称为装动态语言。即Java有一定的动态性。这都是Java的反射机制带来的，我们可以利用Java的反射机制获得类似动态语言的特性，使编程的时候更灵活。

Java Reflection

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

加载完类之后，在堆类就产生了一个Class类型的对象，（一个类只有一个Class对象），这个对象包含了完整的类结构信息，我们可以通过这个对象看到类的结构，所以我们称为反射。

对比.png

反射提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个类的成员变量和方法
在运行时处理注解
生成动态代理

Class类

在Object中定义了以下方法，此方法被所有类继承

public final native Class<?> getClass();

这个方法返回值类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射获得类的名称。

对象照镜子后可以得到的信息：某个类的属性、方法构造器、某个类到底实现了哪些接口、对于每个类而言，JRE都为其保留了一个不变的Class对象。

Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM的.class文件
每个类的实例都会记得自己是由哪个Class实例所产生
通过Class可以完整得到一个类中所有被加载的结构
Class类事Reflection的根源，针对任何你想动态加载、运行的类，都只有先获得Class对象。

Class类方法

Class1

Class2

Class3

获取Class类的实例

若已知具体的类，通过类的class属性获取，该方法最安全，程序性能最高。

Class clazz = Person.class;

已知某个类的实例，调用该实例的getClass()方法获取

Class clazz = person.getClass();

已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()获取。

Class clazz = Class.forName("com.qc.TestReflection.User");

内置基本数据类型可以直接用类名.Type.
还可以利用ClassLoader.

演示

public class Person {

    public String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

   public String showPerson(){
        return "name = "+name + "age = "+ age;
   }
}

public class Student extends Person {

    //班级
    private String className;
    //地址
    public String address;

    public Student() {
    }

    public Student(String name, int age, String className, String address) {
        super(name, age);
        this.className = className;
        this.address = address;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", className='" + className + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public class TestReflect {

    public static void main(String[] args) {
        Class<?> student =null;
        try {
            //通过反射获取类的Class的对象
            //第一种方式获取
            Student student1 = new Student();
            Class aClass = student1.getClass();
            System.out.println("第一种方式获取："+aClass);

            //第二种方式获取
            Class studentClass = Student.class;
            System.out.println("第二种方式获取："+studentClass);

            //第三种方式获取
            student = Class.forName("com.qc.TestReflect.Student");
            System.out.println("第三种方式获取："+student);

            //第四种 :基本内置类型的包装类都有一个Type
            Class<Integer> type = Integer.TYPE;
            System.out.println("第四种方式获取："+type);

            //获得父类类型
            Class<?> superclass = student.getSuperclass();
            System.out.println("获得父类的Class对象："+superclass);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println("===========================================");

        //获取对象的所有公有属性
        Field[] fields = student.getFields();
        for (Field f:fields) {
            System.out.println(f);
        }
        System.out.println(student.toString());
        System.out.println("===========================================");

        //获取对象的有属性,但不包括继承的
        Field[] declaredFields = student.getDeclaredFields();
        for (Field f:declaredFields) {
            System.out.println(f);
        }

        System.out.println("===========================================");
        //获取对象的所有公共方法
        Method[] methods = student.getMethods();
        for (Method m:methods) {
            System.out.println(m);
        }

        System.out.println("===========================================");

        //获得所有方法，但不包括继承的
        Method[] declaredMethods = student.getDeclaredMethods();
        for (Method m: declaredMethods) {
            System.out.println(m);
        }

        System.out.println("===========================================");

        //获取对象所有的公共构造方法
        Constructor<?>[] constructors = student.getConstructors();
        for (Constructor c:constructors) {
            System.out.println(c);
        }

        System.out.println("===========================================");

        //获取对象的所有构造方法
        Constructor<?>[] declaredConstructors = student.getDeclaredConstructors();
        for (Constructor c:declaredConstructors) {
            System.out.println(c);
        }

        System.out.println("===========================================");

       //给属性赋值
        try {
            //获得对象
            Student st = (Student) student.newInstance();
            //第一种 实例化默认构造方法，条用set赋值
            st.setClassName("六年级四班");
            System.out.println(st);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        //第二种  获取全部的构造函数，使用构造函数赋值
        try {
            Constructor<?> declaredConstructor = student.getDeclaredConstructor(String.class, int.class, String.class, String.class);
            Student st2 = (Student) declaredConstructor.newInstance("张三",18,"六年级四班","火星");
            System.out.println(st2);

            //获取方法并执行
            Method showPerson = student.getMethod("showPerson");
            System.out.println(showPerson.invoke(st2));

            try {
                Field className = student.getDeclaredField("className");
		//如果属性是私有的，我们需要关闭安全监测
                className.setAccessible(true);
                className.set(st2,"nnnnn");
                System.out.println( className.get(st2));
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        System.out.println("===========================================");

    }
}

哪些类可以获取Class对象

class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface:接口
[] :数组
enum: 枚举
annotation:注解@interface
primitive type:基本数据类型
void

类加载内存分析

内存图.png

类的加载过程

类加载过程.png

类的加载与ClassLoader的理解

加载：将class字节码文件加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程

验证：确保加载的类的信息复合JVM规范，安全方面没有问题
准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存值都将在方法区中进行分配
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

初始化：

执行类构造器 clinit()方法的过程。类构造器 clinit() 方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息，不是构造该类的构造器）
当初始化一个类的时候，如果发现其父类没有初始化，则需要先触发其父类的初始化
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

什么时候会发生类初始化

类的主动引用（一定会发生初始化）

当虚拟机启动时，先初始化main方法所在的类
new一个类的对象
调用类的静态成员（除了final常量）和静态方法
调用java.lang.reflection包对类进行反射调用
当初始化一个类，它的父类没有被初始化，会先初始化父类

类的被动引用（不会发生类的初始化）

当访问一个静态域时，只有真正声明这个域的类才会被初始化。如通过子类引用父类的静态变量，不会导致子类初始化
通过数组定义引用，不会触发此类的初始化
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

类加载器的作用

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据装换成方法区的运行时数据结构，然后再堆中生成一个代表这个类的java.lang.Class对象，作为方法区中的数据访问入口。

类缓存:标准的Javase类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存一段时间）。不过JVM垃圾回收机制可以回收这些Classs对象。

类加载.png

JVM定义了如下类型的类加载器

类加载器.png

public class Test04 {

    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类加载器的父类加载器->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的祖宗 -> 引导类加载器(根加载器)
        //因为由c/c++编写，用来装载核心类库，所有无法直接获取，因此显示 null
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是由哪个类加载器加载的
        ClassLoader c = Test04.class.getClassLoader();
        System.out.println(c);

        //测试jdk内置类
        ClassLoader c2 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(c2);

        //扩展-> 如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
//        D:\idea_workspaces\net\out\production\net;
//        D:\idea_workspaces\net\lib\mysql-connector-java-8.0.21.jar
    }

}

运行结果

jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
jdk.internal.loader.ClassLoaders$PlatformClassLoader@7f63425a
null
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
null
D:\idea_workspaces\net\out\production\net;D:\idea_workspaces\net\lib\mysql-connector-java-8.0.21.jar

反射