所有框架的底层实现机制

注解

java.Annotation

什么是注解

Annotation是JDK5引入的技术
Annotation的作用：
1、不是程序本身，可以对程序做出解释
2、可以被其他程序（比如编译器）读取
格式：
注解是以“@注解名”在代码中存在的，还可以添加一些参数值，例：@SuppresWarnings(value=”unchecked”)
在什么地方使用
可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

内置注解

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotatiob接口
分析：
1、@innterface，用来声明一个注解，格式：public@interface 注解名{定义内容}
2、其中的每一个方法实际上声明了一个配置参数
3、方法的名称就是参数名称
4、返回值类型就是参数类型（返回值只能是基本类型，Class、String、enum）
5、可以通过default来声明参数的默认值
6、如果只有一个参数成员，一般参数名为value
7、注解元素必须要有值，我们定义注解元素时，经常使用孔字符串，0作为默认值

反射机制概述

Java.Reflection
静态语言
运行时可以改变结构的语言，例如新的函数、对象，设置代码可以被引进，已有的函数可以被删除或者其他结构性上的变化，主要的动态语言有：Object-C，C#，JavaScript、PHP、Python

静态语言
与动态语言不同，运行时不可以改变的语言成为静态语言，
如Java，c++，C
java称之为准动态语言，可以利用反射机制获取类似动态语言的特性。
Reflection，反射，是Java被称为准动态语言的关键，反射机制允许程序在运行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意类的内部属性及方法

Class c = Class.forName("Java.lang.String");

加载完类后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构，类似于镜子，称之为反射
对比
正常的方式：引入需要的“包类”名称——通过new实例化——取得实例化对象
反射的方式：实例化对象——getClass()方法——取得完整的“包类”名称

反射机制提供的功能

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

优点：可以实现动态创建对象和编译，具有灵活性
缺点：对性能有影响，使用反射基本上是一种解释性操作，这类操作慢与直接执行相同的操作

反射相关的主要API

1、一个类在内存中只有一个Class对象
2、一个类被加载之后,类的整个结构都会被封装在class对象中

//反射案例
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取的Class对象
        Class c1 = Class.forName("User");
        Class c2 = Class.forName("User");
        Class c3 = Class.forName("User");
        //一个类在内存中只有一个Class对象
        //一个类被加载之后,类的整个结构都会被封装在class对象中
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        //输出结果是,哈希值相同,证明是同一个对象
    }
}
//实体类:pojo,entity
class User{
    private String name;
    private int id;
    private int age;
    public User() {
    }
    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public int getId() {        return id;    }
    public void setId(int id) {        this.id = id;    }
    public int getAge() {        return age;    }
    public void setAge(int age) {        this.age = age;    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

Class类

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

public final Class getClass()

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

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

1. Class本身也是一个类
2. Class对象只能由系统建立对象
3. 一个加载的类在JVM中只有一个Class实例，这个实例是系统为其创建的
4. 一个Class对象对应的就是一个加载到JVM中的一个.Class文件
5. 每个类的实例都会记住自己是被哪个Class实例所生成
6. 通过CLass可以完整地得到一个类中的所有被加载的结构
7. Class类是Reflection的根源，针对任何想要动态加载、运行的类。只有先获得相应的Class对象

   获得Class类的方法

   | static ClassforName(String name0 | 返回指定类名name的Class对象 | | —- | —- | | Object newInstance（） | 调用缺省构造函数，返回Class对象的一个实例 | | getName() | 返回此Class对象所表示的实体（类、接口、数组类或者void）的名称 | | Class getSupreClass() | 返回当前Class对象的父类的Class对象 | | Class [] getinterfaces() | 获取当前Class对象的接口 | | ClassLoader getClassLoader() | 返回该类的类加载器 | | Constructor [] getConstructors() | 返回一个包含某些Constructor对象的数组 | | Method getMothed(String name,Class..T) | 返回一个Method对象，此对象的参数类型是paramType | | Field [] getDesclaredFiled() | 返回Field对象的一个数组 |

获得Class类的方式

public class TestRelect2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("This man is a "+person);
        //方式一:通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二:forname获得
        Class c2 = Class.forName("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);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5.hashCode());
    }
}
class Person{
    public String name;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
    public Person() {}
    public Person(String name) {this.name = name;}
}
class Student extends Person{
    public Student() {
        this.name = "Student";
    }
}
class Teacher extends Person {
    public Teacher() {
        this.name = "Teacher";
    }
}

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

   Class class=Person.class;

2. 已经具体类，通过类的class属性获取，该方法最为安全可靠，程序性最高

   Class class=person.getClass();

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

   Class class=Class.forName(“demo01.Student”);

4. 内置基本数据类型，可以用：类名.Type

5. 还可以利用ClassLoader

   有哪些类型可以有Class对象

   | class | 外部类，成员，局部内部类，匿名内部类 | | —- | —- | | interface | 接口 | | [] | 数组 | | enum | 枚举 | | annotation | 注解 | | primitive type | 基本数据类型 | | void | 空类型 |

import java.lang.annotation.ElementType;
public class TeatReflect {
    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 = void.class;//void
        Class c8 = 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);
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());    
    }
}

类加载内存分析