学习博客：初识反射机制

动态语言

在运行时可以根据某些条件改变自身结构，包括新的函数、对象、代码
Object-C，C#，JavaScript，PHP，Python

静态语言

运行时结构不可改变
Java，C，C++
Java是准动态语言，可以利用反射机制获得类似动态语言的特性

反射（Reflection）是Java被视作动态语言的关键，允许在程序执行期间借助Reflection API获得任何类的内部信息，也可以直接操作任意对象的内部属性和方法

Class c = Class.forName(“java.lang.String”)

加载完类后，堆内存的方法区中产生了一个Class类型的对象（仅有一个），此对象包含了完整的类的结构信息，通过对象看到类的结构。这种现象称作反射

引入“包类”的名称 --> new实例化 --> 取得实例化对象
反射：实例化对象 --> getClass()方法 --> 得到完整的“包类”名称

//初识反射
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {

        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.reflection.User");
        Class c3 = Class.forName("com.reflection.User");
        Class c4 = Class.forName("com.reflection.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());

    }
}

//实体类 pojo entity
class User{
    private String name;
    private int age;
    private int id;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

在Object类中，getClass方法被所有子类继承，该方法返回值类型是一个Class类，此类是Java反射的源头（通过对象反射求出类的名称）

Class类
透过对象可以得到：某个类的属性、方法和构造器、实现的接口
对每个类来说，JRE都为其保留了一个不变的Class类型的对象，一个Class对象包含了特定的某个结构的信息

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

import java.lang.annotation.ElementType;

//所有类型的class
public class Test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;    //类
        Class c2 = Comparable.class;    //接口
        Class c3 = String[].class;    //一维数组
        Class c4 = int[][].class;   //二维数组
        Class c5 = Override.class;  //注解
        Class c6 = ElementType.class;   //枚举
        Class c7 = Integer.class;   //基本数据类型
        Class c8 = void.class;  //void
        Class c9 = Class.class; //Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);


        //若元素类型与维度一样 则为同一Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }
}