泛型
泛型概念
泛型是在JDK1.5之后引入的，旨在让我们写出更加通用化，更加灵活的代码。通用化的手段在于让数据类型变得参数化，定义泛型时，对应的数据类型是不确定的，泛型方法被调用时，会指定具体类型，其核心目标是为了解决容器类型在编译时安全检查的问题。 泛型：一般用在类、方法、接口中，叫做泛型类、泛型接口、泛型方法
泛型的使用
package demo.generic;
import lombok.Data;
/**
* 泛型类的定义
* @param <T>
*/
@Data
public class GenericClassExample<T> {
//member这个成员变量的类型为T，T的类型由外部指定
private T member;
//泛型类的构造方法形参member的类型也为T，T的类型由外部指定
public GenericClassExample(T member) {
this.member = member;
}
//泛型类中也可以定义普通方法，普通方法的参数也为泛型
public T handleSomething(T target) {
return target;
}
}
泛型的参数不支持基本类型；泛型相关的信息不会进入到运行时阶段
package demo.generic;
public class GenericDemo {
public static void main(String[] args) {
GenericClassExample<String> strExample = new GenericClassExample<>("abc");
GenericClassExample<Integer> intExample = new GenericClassExample<>(123);
System.out.println(strExample.getClass()); // 打印泛型类的类型
System.out.println(intExample.getClass()); // 打印泛型类的类型
}
}
// **********运行结果*********
//class demo.generic.GenericClassExample
//class demo.generic.GenericClassExample
// 我们可以从运行结果看出strExample和intExample的类型是一样的，因此泛型类的类型约束只在编译时有效
能否在泛型里面使用具备继承关系的类？
使用通配符 ?，但是会使得泛型的类型检查失去意义
给泛型加入上边界 <? extends E>
给泛型加入下边界 <? super E>
package demo.generic;
public class GenericDemo {
//给泛型加如上边界 ? extends E， 泛型类型必须是E的类型或其子类
public static void handleMember(GenericClassExample<? extends Number> integerExample) {
Integer result = (Integer) integerExample.getMember() + 100;
System.out.println("result is " + result);
}
//给泛型加入下边界 ? super E ，泛型类型必须是E的类型或其父类
public static void handleSuperMember(GenericClassExample<? super Integer> integerExample) {
Integer result = (Integer) integerExample.getMember() + 100;
System.out.println("result is " + result);
}
public static void main(String[] args) {
GenericClassExample<String> strExample = new GenericClassExample<>("abc");
GenericClassExample<Integer> integerExample = new GenericClassExample<>(123);
GenericClassExample<Number> numberExample = new GenericClassExample<>(new Integer(123));
// handleMember(strExample); // 编译会报错，因为String不是Number的子类
handleMember(integerExample); // 不会报错，因为Integer是Number的子类
handleSuperMember(integerExample); // 不会报错，因为Integer和泛型类的类型相同
handleSuperMember(numberExample ); // 不会报错，因为Number是泛型类Integer的父类
}
}
泛型方法: 使用泛型标识符标识的方法
// <E> 泛型标识符
public static <E> void printArray(E[] array) {
for(E element : array){
System.out.printf("%s",element);
}
}
泛型字母的含义
- E - Element: 在集合中使用，因为集合中存放的是元素
- T - Type: Java类
- K - Key: 键
- V - Value: 值
- N - Number: 数值类型
反射
反射的概念及作用
反射允许程序在运行时来进行自我检查并且对内部的成员进行操作。反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
反射机制的作用
- 在运行时判断任意一个对象所属的类
- 在运行时获取类的对象
- 在运行时访问java对象的属性、方法、构造方法等
java.lang.reflect类库里面主要的类
- Field: 表示类中的成员变量
- Method: 表示类中的方法
- Constructor: 表示类的构造方法
- Array: 该类提供了动态创建数组和访问数组元素的静态方法
反射依赖的Class：用来表示运行时类型信息的对应类
每个类都有唯一一个与之相应的Class对象
Class类为类类型，而Class对象为类类型对象
Class类的特点
- Class类也是类的一种，class则是关键字
- Class类只有一个私有的构造函数，只有JVM能够创建Class类的实例
- JVM中只有唯一一个和类相对应的Class对象来描述其类型信息
获取CLass对象的三种方式
Object -> getClass()
任何数据类型（包括基本数据类型）都有一个“静态”的class属性
通过Class类的静态方法：forName(String className) (常用）
package demo.reflect;
public class ReflectTarget {
public static void main(String[] args) throws ClassNotFoundException {
// 第一种方式获取Class对象
ReflectTarget reflectTarget = new ReflectTarget();
Class reflectClass01 = reflectTarget.getClass();
System.out.println("1st: " + reflectClass01);
//通过第二种方式获取Class对象
Class reflectClass02 = ReflectTarget.class;
System.out.println("2nd: " + reflectClass01);
//比较第一种方式获取得class对象和第二种方式获取得class对象是否为同一个
System.out.println(reflectClass01 == reflectClass02);
// 第三种方式获取Class对象
Class reflectClass03 = Class.forName("demo.reflect.ReflectTarget");
System.out.println("3rd: " + reflectClass03);
//比较第二种方式获取得class对象和第三种方式获取得class对象是否为同一个
System.out.println(reflectClass02 == reflectClass03);
}
}
/************运行结果如下************/
/*
* 1st: class demo.reflect.ReflectTarget
* 2nd: class demo.reflect.ReflectTarget
* true
* 3rd: class demo.reflect.ReflectTarget
* true
* */
/**
* 根据运行结果得知：Class对象有且仅有一个
* **/
```
Class对象就像一面镜子，透过这面镜子可以看到类的结构
反射的主要用法
如何获取类的构造方法并使用
在我们上面自定义的ReflectTarget类中创建各种类型的构造函数，用于测试
// --------构造函数--------
// 访问修饰符为默认的构造函数，即同包可访问得
ReflectTarget(String str) {
System.out.println("(默认)的构造方法 s= " + str);
}
//无参构造函数
public ReflectTarget() {
System.out.println("调用了公有的无参构造函数。。。");
}
//有一个参数的构造函数
public ReflectTarget(char name) {
System.out.println("调用了带有一个参数构造函数，参数为：" + name);
}
//有多个参数的构造函数
public ReflectTarget(String name,int index) {
System.out.println("调用了有多个参数构造函数，参数值为【目标名】：" + name + "【序号】" + index);
}
//受保护的构造函数
protected ReflectTarget(boolean b) {
System.out.println("受保护的构造方法：" + b);
}
//私有的构造函数
private ReflectTarget(int index){
System.out.println("私有的构造方法，序号：" + index);
}
新创建一个类ConstructorCollector测试通过反射获取目标反射类的所有构造方法
package demo.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* 获取构造方法：
* 1）批量构造方法
* public Constructor[] getConstructors() 获取所有”公有的“构造方法
* public Constructor[] getDeclaredConstructors() 获取所有的构造方法（包括私有的、受保护的、默认和公有的）
* 2）获取单个的方法，并调用
* public Constructor getConstructor(Class...parameterTypes) 获取单个的”公有的“构造方法
* public Constructor getDeclaredConstructor(Class...parameterTypes) 获取某个构造方法（可以是私有的、受保护的、默认和公有的）
*
* 调用构造方法： Constructor --> newInstance(Object...intArgs)
*/
public class ConstructorCollector {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Class clazz = Class.forName("demo.reflect.ReflectTarget");
// 获取所有的公有构造方法
System.out.println("**************所有公有的构造方法**************");
Constructor[] conArray = clazz.getConstructors();
for (Constructor con : conArray) {
System.out.println(con);
}
// 获取所有的构造方法
System.out.println("**************所有的构造方法(包括私有的、受保护的、默认和公有的)**************");
conArray = clazz.getDeclaredConstructors();
for (Constructor con : conArray) {
System.out.println(con);
}
//或获取单个带参数的公有构造方法
System.out.println("**************获取公有、带两个参数的构造方法**************");
Constructor con = clazz.getConstructor(String.class,int.class);
System.out.println("con = " + con);
// 获取单个私有的构造方法
System.out.println("**************获取单个私有的构造方法**************");
con = clazz.getDeclaredConstructor(int.class);
System.out.println("con = " + con);
System.out.println("##################################################");
System.out.println("**************通过私有构造方法创建实例**************");
con.setAccessible(true); // 设置暴力访问，忽略掉访问修饰符
ReflectTarget reflectTarget = (ReflectTarget) con.newInstance(1);
}
}
/***
* 运行结果如下：
* **************所有公有的构造方法**************
* public demo.reflect.ReflectTarget(java.lang.String,int)
* public demo.reflect.ReflectTarget()
* public demo.reflect.ReflectTarget(char)
* **************所有的构造方法(包括私有的、受保护的、默认和公有的)**************
* private demo.reflect.ReflectTarget(int)
* protected demo.reflect.ReflectTarget(boolean)
* public demo.reflect.ReflectTarget(java.lang.String,int)
* demo.reflect.ReflectTarget(java.lang.String)
* public demo.reflect.ReflectTarget()
* public demo.reflect.ReflectTarget(char)
* **************获取公有、带两个参数的构造方法**************
* con = public demo.reflect.ReflectTarget(java.lang.String,int)
* **************获取单个私有的构造方法**************
* con = private demo.reflect.ReflectTarget(int)
* ##################################################
* **************通过私有构造方法创建实例**************
* 私有的构造方法，序号：1
*/
如何获取类的字段并使用
在我们上面自定义的ReflectTarget类中创建各种不同访问修饰符修饰的字段，用于测试
// --------字段--------
public String name;
protected int index;
char type;
private String targetInfo;
@Override
public String toString() {
return "ReflectTarget{" +
"name='" + name + '\'' +
", index=" + index +
", type=" + type +
", targetInfo='" + targetInfo+ '\'' +
'}';
}
新创建一个类FieldCollector 测试通过反射获取目标反射类的所有成员变量
package demo.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* 获取成员变量并调用：
* 1）批量的
* Field[] getFields() 获取所有的”公有字段”
* Field[] getDeclaredFields() 获取所有字段（包括私有的、受保护的、默认和公有的）
* 2）获取单个的
* public Field getField(String fieldName) 获取单个的”公有的“字段
* public Field getDeclaredField(String fieldName) 获取某个字段（可以是私有的、受保护的、默认和公有的）
*
* 设置字段值： Field --> public void set(Object obj,Object value)
* 参数说明：
* 1. obj：要设置的字段所对应的对象
* 2. value：要为字段设置的值
*/
public class FieldCollector {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//获取class对象
Class reflectTargetClass = Class.forName("demo.reflect.ReflectTarget");
//获取所有的公有字段
System.out.println("**************获取所有的公有字段**************");
Field[] fieldArray = reflectTargetClass.getFields();
for (Field field : fieldArray) {
System.out.println(field);
}
//获取所有的字段
System.out.println("**************获取所有字段（包括私有的、受保护的、默认和公有的）**************");
fieldArray = reflectTargetClass.getDeclaredFields();
for (Field field : fieldArray) {
System.out.println(field);
}
// 获取公有字段并赋值
System.out.println("**************获取公有字段并赋值**************");
Field field = reflectTargetClass.getField("name");
System.out.println("公有的字段 name = " + field);
// 通过反射调用无参构造方法，并使用无参构造创建对象
ReflectTarget reflectTarget = (ReflectTarget)reflectTargetClass.getConstructor().newInstance();
// 给获取对象的field属性赋值
field.set(reflectTarget,"待反射一号");
// 验证对应的值 name
System.out.println("验证name: " + reflectTarget.name); // 因为name属性是公有的，所以可以直接通过实例调用
System.out.println("**************获取私有字段targetInfo并赋值**************");
field = reflectTargetClass.getDeclaredField("targetInfo");
System.out.println(field);
field.setAccessible(true); // 设置暴力访问
field.set(reflectTarget,"13730862985");
// 因为targetInfo属性是私有的，不能直接通过实例调用，由于我们重写了toString方法，所以直接打印reflectTarget对象就好了
System.out.println("验证targetInfo: " + reflectTarget);
}
}
/**
* 运行结果如下：
* **************获取所有的公有字段**************
* public java.lang.String demo.reflect.ReflectTarget.name
* **************获取所有字段（包括私有的、受保护的、默认和公有的）**************
* public java.lang.String demo.reflect.ReflectTarget.name
* protected int demo.reflect.ReflectTarget.index
* char demo.reflect.ReflectTarget.type
* private java.lang.String demo.reflect.ReflectTarget.targetInfo
* **************获取公有字段并赋值**************
* 公有的字段 name = public java.lang.String demo.reflect.ReflectTarget.name
* 调用了公有的无参构造函数。。。
* 验证name: 待反射一号
* **************获取私有字段targetInfo并赋值**************
* private java.lang.String demo.reflect.ReflectTarget.targetInfo
* 验证targetInfo: ReflectTarget{name='待反射一号', index=0, type= , targetInfo='13730862985'}
*/
注意：通过getField()方法可以获取到从父类继承的公有字段，但getDeclareField()方法是获取不到从父类继承的字段的
如何获取类的方法并调用
在在我们上面自定义的ReflectTarget类中创建被各种不同访问修饰符修饰的方法，用于测试
package demo.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 获取成员方法并调用：
* 1）批量的
* public Method[] getMethods() 获取所有的”公有方法”(包含了父类的方法，也包含了Object类中的公有方法)
* public Method[] getDeclaredMethods() 获取所有成员方法（包括私有的、受保护的、默认和公有的）
* 2）获取单个的
* public Method getMethod(String name,Class<?>...parameterTypes) 获取单个的”公有的“字段
* 参数：
* name: 方法名
* Class...: 形参的Class类型对象
* public Method getDeclaredMethod(String name,Class<?>...parameterTypes) 获取某个字段（可以是私有的、受保护的、默认和公有的）
*
* 调用方法：
* Method --> public Object invoke(Object obj,Object...args);
* 参数说明：
* obj: 待调用方法方法的对象
* args: 调用方法时所传递的实参
*/
public class MethodCollector {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//获取class对象
Class reflectTargetClass = Class.forName("demo.reflect.ReflectTarget");
// 获取所有的公有方法
System.out.println("*******************获取所有的public方法，包括父类和Object*******************");
Method[] methodArray = reflectTargetClass.getMethods();
for (Method method : methodArray) {
System.out.println(method);
}
// 获取该类所有的方法
System.out.println("*******************获取该类所有的方法，包括私有的*******************");
methodArray = reflectTargetClass.getDeclaredMethods();
for (Method method : methodArray) {
System.out.println(method);
}
// 获取单个公有方法
System.out.println("*******************获取公有的show1()*******************");
Method method = reflectTargetClass.getMethod("show1", String.class);
System.out.println(method);
// 通过反射调用无参构造方法，并使用无参构造创建对象
ReflectTarget reflectTarget = (ReflectTarget)reflectTargetClass.getConstructor().newInstance();
method.invoke(reflectTarget,"待反射方法一号");
System.out.println("*******************获取私有的show4()*******************");
method = reflectTargetClass.getDeclaredMethod("show4", int.class);
System.out.println(method);
method.setAccessible(true);
// 接受show4()的返回值
String result = String.valueOf(method.invoke(reflectTarget, 100)) ;
System.out.println(result);
}
}
/**
* 运行结果如下：我们从运行结果可以看到通过getMethods(),获取到Object类中的公有方法
* *******************获取所有的public方法，包括父类和Object*******************
* public static void demo.reflect.ReflectTarget.main(java.lang.String[]) throws java.lang.ClassNotFoundException
* public java.lang.String demo.reflect.ReflectTarget.toString()
* public void demo.reflect.ReflectTarget.show1(java.lang.String)
* public final void java.lang.Object.wait() throws java.lang.InterruptedException
* public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
* public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
* public boolean java.lang.Object.equals(java.lang.Object)
* public native int java.lang.Object.hashCode()
* public final native java.lang.Class java.lang.Object.getClass()
* public final native void java.lang.Object.notify()
* public final native void java.lang.Object.notifyAll()
* *******************获取该类所有的方法，包括私有的*******************
* public static void demo.reflect.ReflectTarget.main(java.lang.String[]) throws java.lang.ClassNotFoundException
* public java.lang.String demo.reflect.ReflectTarget.toString()
* public void demo.reflect.ReflectTarget.show1(java.lang.String)
* private java.lang.String demo.reflect.ReflectTarget.show4(int)
* protected void demo.reflect.ReflectTarget.show2()
* void demo.reflect.ReflectTarget.show3()
* *******************获取公有的show1()*******************
* public void demo.reflect.ReflectTarget.show1(java.lang.String)
* 调用了公有的无参构造函数。。。
* 调用了公有的，String参数的show1(): str = 待反射方法一号
* *******************获取私有的show4()*******************
* private java.lang.String demo.reflect.ReflectTarget.show4(int)
* 调用了私有的，并且有返回值的，int参数的show4(): index = 100
* show4Result
*/
注解
注解介绍及作用
由于反射需要获取到相关的类全名（类名+包名），因此我们还需要记录哪些类是通过反射来获取的。我们可以通过XML来保存类相关的信息已供反射用，此外，我们还可以通过注解来保存类相关信息以供反射调用。 注解：提供一种为程序元素设置元数据的方法
- 元数据是添加到程序元素如方法、字段、类和包上的额外信息
- 注解是一种分散式的元数据设置方式，XML是集中式的设置方式
- 注解不能直接干扰程序运行
- 反编译字节码文件的指令：javap -verbose com.reminis.demo.annotation.TestAnnotation,通过反编译可以看到我们的自定义注解自动继承了Annotation
- 注解的功能
- 作为特定得标记，用于告诉编译器一些信息
- 编译时动态处理，如动态生成代码
- 运行时动态处理，作为额外信息的载体，如获取注解信息
- 注解的分类
- 标准注解：Override、Deprecated、SuppressWarnings
- 元注解：@Retention、@Target、@Inherited、@Documented，用于修饰注解的注解，通常用在注解的定义上
- @Target：注解的作用目标，描述所修饰注解的使用范围
- packages、types(类、接口、枚举、Annotation类型)
- 类型成员（方法、构造方法、成员变量、枚举值）
- 方法参数和本地变量（如循环变量、catch参数）
- @Retention：注解的生命周期（标注注解保留时间的长短）
- @Documented：注解是否应当被包含在JavaDoc文档中
- @Inherited：是否允许子类继承该注解
自定义注解的实现
自定义注解自动实现了 java.lang.annotation.Annotation
public @interface 注解名{
修饰符 返回值 属性名() 默认值;
修饰符 返回值 属性名() 默认值;
...
}
注解属性支持的类型：所有的基本类型（int,float,boolean,byte,double,char,long,short）、 String 类型、 Class类型、Enum类型、Annotation类型、以上所有类型的数组。 我们现在自定义一个注解PersonInfoAnnotation，可以用在字段上，在程序运行时有效，如下：
package demo.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义注解
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonInfoAnnotation {
//名字
public String name();
// 年龄
public int age() default 19;
// 性别
public String gender() default "男";
// 开发语言
public String[] language();
}
我们再自定义一个注解CourseInfoAnnotation，该注解可以用在类和方法上，在程序运行时有效，如下：
package demo.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CourseInfoAnnotation {
// 课程名称
public String courseName();
// 课程 标签
public String courseTag();
// 课程简介
public String courseProfile();
// 课程代号
public int courseIndex() default 107;
}
新创建一个SelfStudyCourse类，在该类上及该类的字段和方法上，使用我们上面的已经定义好了的注解
package demo.annotation;
@CourseInfoAnnotation(courseName = "计算机网络",courseTag = "计算机基础",
courseProfile = "计算机网络学习的核心内容就是网络协议的学习。" +
"网络协议是为计算机网络中进行数据交换而建立的规则、标准或者说是约定的集合。" +
"因为不同用户的数据终端可能采取的字符集是不同的，两者需要进行通信，必须要在一定的标准上进行")
public class SelfStudyCourse {
@PersonInfoAnnotation(name = "新一",language = {"Java","C++","Go","Python"})
public String author;
@CourseInfoAnnotation(courseName = "Linux 教程",courseTag = "编程基础",
courseProfile = "Linux 遵循 GNU 通用公共许可证（GPL），任何个人和机构都可以自由地使用 Linux 的所有底层源代码，也可以自由地修改和再发布。" +
"由于 Linux 是自由软件，任何人都可以创建一个符合自己需求的 Linux 发行版",courseIndex = 208)
public void getCourseInfo(){
}
}
创建测试类AnnotationDemo，调用上面使用了自定义注解的类的方法，查看运行信息
package demo.annotation;
public class AnnotationDemo {
public static void main(String[] args) {
SelfStudyCourse selfStudyCourse = new SelfStudyCourse();
selfStudyCourse.getCourseInfo();
System.out.println("finish");
}
}
/**
* 运行结果：
* finish
* 根据运行结果可以看出，在程序中如果不对注解进行处理，和不加注解输出的信息是一致的，
* */
如果我们不对注解进行处理，那和不加是没有区别的，那我们如何获取注解上得信息呢？通过前面说到得反射，我们查看反射涉及到得几个主要类(Field,Method,Constructor,Class)得源码可以知道，这些跟反射相关得类都实现了AnnotatedElement接口，我们通过查看AnnotatedElement接口的源码，常用的有如下几个方法：
- Annotation[] getAnnotations(); // 用来获取对象上的所有注解，包括继承过来的
- T getAnnotation(Class annotationClass); // 获取对象上单个指定的注解
- boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)； //用来判断是否有某个指定的注解
现在我们通过反射来获取类注解上的信息，代码实现如下:
package demo.annotation;
import java.lang.annotation.Annotation;
public class AnnotationParse {
//解析类上面的注解
public static void parseTypeAnnotation() throws ClassNotFoundException {
Class<?> clazz = Class.forName("demo.annotation.SelfStudyCourse");
// 这里获取的是class对象的注解，而不是其里面的方法和成员变量的注解
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
CourseInfoAnnotation courseInfoAnnotation = (CourseInfoAnnotation) annotation;
System.out.println("课程名: " +courseInfoAnnotation.courseName() + "\n" +
"课程标签: " + courseInfoAnnotation.courseTag() + "\n" +
"课程简介: "+ courseInfoAnnotation.courseProfile() + "\n" +
"课程代号: " + courseInfoAnnotation.courseIndex());
}
}
public static void main(String[] args) throws ClassNotFoundException {
parseTypeAnnotation();
}
}
/**
* 程序运行结果如下：
* 课程名: 计算机网络
* 课程标签: 计算机基础
* 课程简介: 计算机网络学习的核心内容就是网络协议的学习。网络协议是为计算机网络中进行数据交换而建立的规则、标准或者说是约定的集合。因为不同用户的数据终端可能采取的字符集是不同的，两者需要进行通信，必须要在一定的标准上进行
* 课程代号: 107
*/
现在通过来反射来获取成员变量和方法上的注解信息
// 解析字段上的注解信息
public static void parseFieldAnnotation() throws ClassNotFoundException {
Class<?> clazz = Class.forName("demo.annotation.SelfStudyCourse");
// 获取该对象的所有成员变量
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 判断成员变量中是否有指定注解类型的注解
boolean hasAnnotation = field.isAnnotationPresent(PersonInfoAnnotation.class);
if (hasAnnotation) {
PersonInfoAnnotation personInfoAnnotation = field.getAnnotation(PersonInfoAnnotation.class);
System.out.println("名字: " + personInfoAnnotation.name() + "\n" +
"年龄: " + personInfoAnnotation.age() + "\n" +
"性别: " + personInfoAnnotation.gender());
for (String language : personInfoAnnotation.language()) {
System.out.println("课程名: " + language);
}
}
}
}
// 解析方法上的注解信息
public static void parseMethodAnnotation() throws ClassNotFoundException {
Class<?> clazz = Class.forName("demo.annotation.SelfStudyCourse");
// 获取该对象的所有成员变量
Method[] methods = clazz.getMethods();
for (Method method : methods) {
// 判断方法中是否有指定注解类型的注解
boolean hasAnnotation = method.isAnnotationPresent(CourseInfoAnnotation.class);
if (hasAnnotation) {
CourseInfoAnnotation methodAnnotation = method.getAnnotation(CourseInfoAnnotation.class);
System.out.println("课程名: " +methodAnnotation.courseName() + "\n" +
"课程标签: " + methodAnnotation.courseTag() + "\n" +
"课程简介: "+ methodAnnotation.courseProfile() + "\n" +
"课程代号: " + methodAnnotation.courseIndex());
}
}
}
注解获取属性值的底层实现，是通过JVM为注解生成代理对象。
注解的工作原理
- 通过键值对的形式为注解属性赋值
- 编译器检查注解的使用范围，将注解信息写入元素属性表，
- 运行时JVM将RUNTIME的所有注解属性取出并最终存入map里
- 创建AnnotationInvocationHandler实例并传入前面的map中
- JVM使用JDK动态代理为注解生成代理类，并初始化对应的处理器(AnnotationInvocationHandler)
- 调用invoke方法，通过传入方法名返回注解对应的属性值