反射基本概述

一、Java反射机制概述

编程语言可以分为动态语言和静态语言
动态语言是一类在运行时可以改变其结构的语言，主要有PHP、Python、JavaScrip等。
静态语言是一类在运行时结构不可变的语言，主要有Java、C、C++
Java不是动态语言，但可以被称为"准动态语言"。即Java有一定的动态性，而让Java实现类动态语言特点的关键就是反射机制。
反射机制允许程序程序在执行期借助反射API取得任何类的内部消息，能够直接操作任意对象的内部属性。

二、理解Class类并获取Class实例

加载完类之后，在堆内存的方法区中会产生一个Class类型的对象(一个类值对应一个Class对象)，这个对象包含了完整的类的结构信息，可以通过这个对象看到类的结构。这个对象就像一面镜子，透过镜子看到类的结构，因此我们形象的称之为反射。

Class类

在Object类中定义了方法public final native Class<?> getClass()，此方法将被所有子类继承。返回值类型为Class类，此类事Java反射的源头。
对于每个类，JRE都为其保留一个不变的Class类型的对象，对象通过反射后可以得到的信息有：某个类的属性、方法和构造器、某个类实现了哪些接口。

如何获取Class类的实例

package Reflect;

public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException{
        Person person = new Student();
        //方式一：getClass()方法获得，通过某个实例调用
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //方式二：forname获得，已知一个类的全类名，且该类在类路径下
        Class c2 = Class.forName("Reflect.Student");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得，已知具体类，该方法最为安全，性能最高
        Class c3= Student.class;
        System.out.println(c3.hashCode());

        //方式四：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4.hashCode());
        System.out.println(c4);

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5.hashCode());
        System.out.println(c5);

    }
}

class Person{
    String name;
    Person(){};

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

    public String getName() {
        return name;
    }

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

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}
class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

460141958
460141958
460141958
1163157884
int
1956725890
class Reflect.Person

哪些类型可以有Class对象

class, interface, [], enum, annotation, 基本数据类型，void

三、Java反射优点和缺点

优点：可以实现动态创建对象和编译，体现出很大的灵活性
缺点：对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。