【狂神说JAVA】注解和反射

一、什么是注解

• Annotation作用：
  （1）不是程序本身，可以对程序作出解释（和注释comment没有区别）；
  （2）可以被其他程序（如编译器）读取。
• Annotation格式：
  @注释名 如@SuppressWarning(value=“unchecked”)
• 使用场景
  可以附加在package，class，method，field等，相当于给他们添加了额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问。

二、内置注解

• 在java.lang包里
• 示例：
  （1）@Deprecated 用于修饰方法、属性和类，表示不鼓励程序员使用这样的元素（但是可以使用），通常是因为它很危险或者存在更好的选择。
  （2） @SuppressWarning 用来抑制编译时的警告信息。需要添加一个参数才能正确使用，其中参数都是已经定义好的了，选择性使用即可。
  如 @SuppressWarning(value=“all”)
  @SuppressWarning(value=“unchecked”) // 未检查的
  @SuppressWarning(value={“unchecked”,“deprecation”})

三、元注解

• 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，用来说明其他annotation类型，在java.lang.annotation包中。
• 四个元注解：
  （1）@Target 用于描述注解的使用范围；
  （2）@Retention 用于描述注解的生命周期，表示需要在什么级别保存该注释信息 （SOURCE < CLASS < RUNTIME）；
  （3）@Documented 说明该注解将被包含在javadoc中；
  （4）@Inherited 说明子类可以继承父类中的该注解。

四、自定义注解

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

public class Test{
	// 注解如果没有默认值，就必须给注解赋值
	@MyAnnotation1(schools = {"德玛西亚"，"弗雷尔卓德"},age = 384)
	public void test1(){}

	// value可以省略
	@MyAnnotation2("提莫")
	public void test2(){}
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation1{
	// 注解的参数：参数类型+参数名（）;
	String name() default "";
	int age();
	int id() default -1;
	String[] schools() default {"清华大学","北京大学"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
	String value();
}

五、反射概述

• Reflection是java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
  这个对象就像一面镜子，可以通过这个对象看到类的结构，故称之为反射。

Class C = Class.forName("java.lang.String");

• 加载完类之后，在堆内存的地方区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。

六、获得反射对象

• Java反射机制提供的功能：
  （1）在运行时判断任意一个对象所属的类；
  （2）在运行时构造一个类的对象；
  （3）在运行时判断任意一个类所具有的成员变量和方法；
  （4）在运行时获取泛型信息；
  （5）在运行时调用任意一个对象的成员变量和方法；
  （6）在运行时处理注解；
  （7）生成动态代理。
• 优点：可以实现动态创建对象和编译，体现出很大的灵活性。
• 缺点：对性能有影响。使用反射基本上是一种解释操作。我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
• 反射相关的 主要API：
  （1）java.lang.Class 代表一个类
  （2）java.lang.reflect.Method 代表类的方法
  （3）java.lang.reflect.Field 代表类的成员变量
  （4）java.lang.reflect.Constructor 代表类的构造器
• 在Object类中定义了以下的方法，此方法将被所有子类继承
  public final Class getClass()
  以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

// 通过反射获取类的Class对象
Class c1 = Class.forName("com.kuang.reflection.User");
Class c2 = Class.forName("com.kuang.reflection.User");
Class c3 = Class.forName("com.kuang.reflection.User");
Class c4 = Class.forName("com.kuang.reflection.User");

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

==========================
// 实体类：pojo,entity
class User{...}

七、得到Class类的几种方式

• Class类
  （1）可以得到：某个类的属性、方法和构造器，某个类到底实现了哪些借口。
  （2）Class本身也是一个类；
  （3）Class对象只能由系统建立对象；
  （4）一个加载的类在JVM中只会有一个Class示例；
  （5）一个Class对象对应的是一个加载到JVM中的一个.class文件；
  （6）每个类的实例都会记得自己是由哪个Class实例所生成；
  （7）通过Class可以完整地得到一个类中的所有被加载的结构；
  （8）Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。
• 获取Class类的实例
  （1）若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高；
  Class clazz = Person.class;
  （2）已知某个类的实例，调用该实例的getClass()方法获取Class对象；
  Class clazz = person.getClass();
  （3）已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法;foeName()获取，可能抛出ClassNotFoundException；
  Class clazz = Class.forName("demo.Student");
  （4）内置基本数据类型使用类名.Type；
  （5）利用ClassLoader。

class Person{
    String name;

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

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

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

public static void main(String[]args){
        Person person = new Student();
        System.out.println("这个人是："+person.name);

        // 方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());  // 1163157884

        // 方式二：forname获得
        Class c2 = Class.forName("com.kuang.reflection.Student");
        System.out.println(c2.hashCode());  // 1163157884

        // 方式三：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());  // 1163157884

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

        // 获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);  // class com.kuang.reflection.Person

    }

八、所有类型的Class对象

• 哪些类型可以有Class对象？
  （1）class ：外部类、成员（成员内部类，静态内部类）、局部内部类、匿名内部类；
  （2）interface：接口 ；
  （3）[] ：数组；
  （4）enum ：枚举；
  （5）annotation ：注解@interface
  （6）primitive type ：基本数据类型
  （7）void

 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
=============输出===============
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Intefer
void
class java.lang.Class
================================
int[] a = new int[10];
int[] b = new int [100];
System.out.println(a.getClass().hashCode()); // 1163157884
System.out.println(b.getClass().hashCode()); // 1163157884

• 总结：只要元素类型与维度一样，就是同一个Class

九、类加载内存分析

十、分析类初始化

十一、类加载器

十二、获取类的运行时结构

十三、动态创建对象执行方法

十四、性能对比分析

十五、获取泛型信息

十六、获取注解信息

十七、本章小结