Java注解和反射

1. 注解

1.1 注解的概念

Annotation的作用：
不是程序本身，可以对程序作出解释
可以被其他程序读取，通过反射的原理读取
Annotation的格式： @注解名(参数)
Annotation的使用：
可以附加在package class method field

1.2 内置注解

@Override 定义在java.lang.Override，此注释只用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明
@Deprecated 定义在java.lang.Deprecated，此注释可以用于修饰方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为他很危险或者存在更好的选择
@SuppressWarnings 定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，需要添加参数

1.3 元注解

元注解的作用是负责注解其他注解的，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型做说明。
@Target 用于描述注解的使用范围
ElementType: Type用在类上 Method用在方法上等等
@Retention 表示需要在什么级别保存该注解信息，用于描述注解的生命周期（source < class < runtime），RetentionPolicy.RUNTIME表示只在运行时有效
@Document 说明该注解将被包含在javadoc中
@Inherited 说明子类可以继承父类中的该注解

//定义注解
@Target(value = {ElementType.Method, ElementType.Type})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation(
)

1.4 自定义注解

1. public @interface 注解名{定义内容}
2. 每个方法实际上是声明了一个配置参数
3. 方法的名称就是参数的名称
4. 返回值类型就是参数的类型，返回值只能是基本类型class String enum
5. 可以通过default来声明参数的默认值
6. 如果只有一个参数成员，一般参数为value，这样在使用的时候可以不用写value=
7. 注解元素必须有值，定义注解元素时，通常使用空字符串、0作为默认值

**参数格式：参数类型 参数名();

//自定义注解
public class Test{
	@Annotation(age = 18)
	public void test(){
	}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
	//注释的参数
	//如果没有default，在使用注解的时候必须定义参数，否则会报错；有default，就可以不用定义该参数
	String name() default "";
	String[] school() default {"aaa","bbb"};
	int age();
}

2. 反射

2.1 反射的概念

反射是被Java视为动态语言的关键，反射机制允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
获得反射对象
Class c = Class.forName(“包类名”)
加载完类之后，在堆内存的方法区中就产生一个Class类对象（一个类只有以Class对象），这个对象包含完整类信息，可以通过类的对象看到类的结构，就像一面镜子。

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

2.2 获取Class类的实例

对于每个类而言，JRE都为其保留一个不变的Class类型对象。

1. Class本身就是一个类，Class对象只能有系统创建
2. 一个加载的类在JVM中只会有一个Class实例，一个Class对象对应的是一个加载到JVM中的.class文件
3. 每个类的示例都会记得自己是由哪个Class示例所生成
4. 通过Class可以完整地得到一个类中的所有被加载的结构

a. 已知具体的类：Class clazz = Person.class;
b. 已知类的实例：Class clazz = person.getClass();
c. 已知一个类的全类名：Class clazz = Class.forName(“com.demo.Person”);
d. 通过子类获得父类类型：Class clazz = c1.getSuperclass();

【哪些类型可以有Class对象】
class interface 数组 enum annotation primitive type void

2.3 类的加载

类加载的过程：

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
链接：将Java类的二进制代码合并到JVM的运行状态中的过程
验证：确保加载的类信息符合JVM规范，没有安全问题
准备：正式为类变量(static)分配内存，并设置类变量默认初始值的阶段，这些内存都将在方法去中进行分配
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
初始化：
执行类构造器<clinit>()方法的过程，类构造器是构造类信息的，不是构造该类对象的构造器
当初始化一个类的时候，如果发现父类没有进行初始化，先要触发父类的初始化
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步

Class的类在加载的过程中就产生了，在堆存放，new对象的时候直接去找这个类

2.4 类的初始化

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

1. 当虚拟机启动，先初始化main方法所在的类
2. new一个类的对象
3. 调用类的静态成员（除了final常量）和静态方法
4. 使用java.lang.reflect包的方法对类进行反射调用
5. 当初始化一个类，如果其父类没有初始化，会先初始化他的父类

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

1. 当访问一个静态域时，只有真正声明这个域的类才会被初始化，如当通过子类引用父类的静态变量，不会导致子类初始化
   Father： static int b =10;
   Son: ***
   main: Son.b
2. 通过数组定义类引用，不会触发此类的初始化
   Son[] array = new Son[5];
3. 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
   Son: static final int M = 10;
   main: Son.M

2.5 类加载器

类加载器的作用：把类装载进内存

获取系统类加载器：ClassLoader cl = ClassLoader.getSystemClassLoader();
获取系统类加载器的父类加载器->扩展类加载器：ClassLoader clp = cl.getParent();
获取扩展类加载器的父类->根加载器(c/c++)：ClassLoader clr = clp.getParent();
查看指定类是哪个加载器加载的：ClassLoader cl = Class.forName(“包类名”).getClassLoader();
获取系统类加载器可以加载的路径：System.getProperty(“java.class.path”);

3 创建运行时类的对象

3.1 获取运行时类的完整结构

通过反射获取运行时类的完整结构：Field Method Constructor Superclass Interface Annotation

Class cl = Class.forName("包类名");
//获得类名
String name1 = cl.getName(); //包名 + 类名
String name2 = cl.getSimpleName(); //类名
//获得类的属性
Field[] fields1 = cl.getFields(); //只能找到public属性
Field[] fields2 = cl.getDeclaredFields(); //找到全部的属性
Field field = cl.getDeclaredField("name"); //获取指定属性

//获得类的方法
Method[] methods1 = cl.getMethods(); //获得本类及父类的全部public方法
Method[] methods2 = cl.getDeclaredFields(); //获取的本类的所有方法（没有父类）

//获得指定的构造器
Constructor[] c = cl.getConstructors();  //获得本类的public构造方法
Constructor[] c = cl.getDeclaredConstructors();
Constructor cc = cl.getConstructor(参数类型,参数类型)

3.2 动态创建对象执行方法

方法一：调用类的newInstance()方法，必须有一个无参的构造器；类的构造器访问权限需要足够

//通过反射创建对象
Class cl = Class.forName("***.User");
User user = (User)cl.newInstance();

如果类中没有无参构造器，怎么动态创建对象？

1. 通过Class类的getDeclaredConstructor(Class…parameterTypes)取得本类的指定形参类型的构造器
2. 向构造器的形参中传递一个数组进去，里面包含了构造器中所需的各个参数
3. 通过Constructor实例化对象

Class cl = Class.forName("***.User");
Constructor ct = cl.getDeclaredConstructor(String.class, int.class, int.class);
User user = ct.newInstance("hello",19,20);

通过反射调用方法，通过反射获取方法，然后通过invoke调用对象的方法

Class cl = Class.forName("***.User");
User user = (User)cl.newInstance();
//通过反射获取一个方法
Method setName = cl.getDeclaredMethod("setName",String.class);
setName.invoke(user, "hello");

通过反射操作属性，通过反射获取属性，然后通过get/set进行操作

~~~java
Class cl = Class.forName("***.User");
User user = (User)cl.newInstance();
Field name = cl.getDeclaredField("name");
//对属性取消安全检测，否则对Private的属性不能进行操作
name.setAccessible(true);
name.set(user, "hi");

注意Field Method Constructor都有setAccessible方法，setAccessible方法能够提高执行效率

4. 通过反射操作泛型