Java 面向对象（十四）
反射
反射是框架设计的灵魂
一、类的加载时机
当程序要使用某个类时，如果该类还未被加载到内存中，系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
- 加载 ：就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
- 连接：验证 是否有正确的内部结构，并和其他类协调一致。准备 负责为类的静态成员分配内存，并设置默认初始化值。
- 初始化：初始化成员变量等等。
加载时机
- 创建类的实例
- 访问类的静态变量，或者为静态变量赋值
- 调用类的静态方法
- 初始化某个类的子类
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
二、类加载器
什么是类加载器classLoader
负责将 .class文件加载到内存中，并为之生成对应的Class对象。
虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
类加载器分类
（1）根类加载器
- 也被称为引导类加载器，负责Java核心类的加载
- 比如System，String等。在JDK中JRE的lib目录下rt.jar文件中
（2）扩展类加载器
- 负责JRE的扩展目录中jar包的加载。
- 在JDK中JRE的lib目录下ext目录
（3）系统类加载器
- 负责在JVM启动时加载来自java命令的class文件
- 以及classpath环境变量所指定的jar包和类路径
三、什么是反射
创建一个对象的三个阶段
- 源文件阶段 .java的文件
- 字节码阶段 .class
- 创建对象阶段 new 对象名称
内省
在运行时能够获取JavaBean当中的属性名称和get与set方法
反射
- JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
- 对于任意一个对象，都能够调用它的任意一个方法和属性；
- 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
- 想要使用反射，就必须得要获取字节码文件。
四、反射机制的相关类
| 类名 | 用途 |
|---|---|
| Class类 | 代表类的实体，在运行的Java应用程序中表示类和接口 |
| Field类 | 代表类的成员变量（成员变量也称为类的属性） |
| Method类 | 代表类的方法 |
| Constructor类 | 代表类的构造方法 |
（1）Class类
- 获得类相关的方法
| 方法 | 用途 |
|---|---|
| forName(String className) | 根据类名返回类的对象 |
| getName() | 获得类的完整路径名字 |
| newInstance() | 创建类的实例 |
| getPackage() | 获得类的包 |
| getSimpleName() | 获得类的名字 |
| getSuperclass() | 获得当前类继承的父类的名字 |
| getInterfaces() | 获得当前类实现的类或是接口 |
| asSubclass(Class clazz) | 把传递的类的对象转换成代表其子类的对象 |
| Cast | 把对象转换成代表类或是接口的对象 |
| getClassLoader() | 获得类的加载器 |
| getClasses() | 返回一个数组，数组中包含该类中所有公共类和接口类的对象 |
| getDeclaredClasses() | 返回一个数组，数组中包含该类中所有类和接口类的对象 |
- 获得类中属性相关的方法
| 方法 | 用途 |
|---|---|
| getField(String name) | 获得某个公有的属性对象 |
| getFields() | 获得所有公有的属性对象 |
| getDeclaredField(String name) | 获得某个属性对象 |
| getDeclaredFields() | 获得所有属性对象 |
- 获得类中注解相关的方法
| 方法 | 用途 |
|---|---|
| getAnnotation(ClassannotationClass) | 返回该类中与参数类型匹配的公有注解对象 |
| getAnnotations() | 返回该类所有的公有注解对象 |
| getDeclaredAnnotation(ClassannotationClass) | 返回该类中与参数类型匹配的所有注解对象 |
| getDeclaredAnnotations() | 返回该类所有的注解对象 |
- 获得类中构造器相关的方法
| 方法 | 用途 |
|---|---|
| getConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法 |
| getConstructors() | 获得该类的所有公有构造方法 |
| getDeclaredConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法 |
| getDeclaredConstructors() | 获得该类所有构造方法 |
- 获得类中方法相关的方法
| 方法 | 用途 |
|---|---|
| getMethod(String name, Class...<?> parameterTypes) | 获得该类某个公有的方法 |
| getMethods() | 获得该类所有公有的方法 |
| getDeclaredMethod(String name, Class...<?> parameterTypes) | 获得该类某个方法 |
| getDeclaredMethods() | 获得该类所有方法 |
- 类中其他重要的方法
| 方法 | 用途 |
|---|---|
| isAnnotation() | 如果是注解类型则返回true |
| isAnnotationPresent(Class<? extends Annotation> annotationClass) | 如果是指定类型注解类型则返回true |
| isAnonymousClass() | 如果是匿名类则返回true |
| isArray() | 如果是一个数组类则返回true |
| isEnum() | 如果是枚举类则返回true |
| isInstance(Object obj) | 如果obj是该类的实例则返回true |
| isInterface() | 如果是接口类则返回true |
| isLocalClass() | 如果是局部类则返回true |
| isMemberClass() | 如果是内部类则返回true |
（2）Field类
| 方法 | 用途 |
|---|---|
| equals(Object obj) | 属性与obj相等则返回true |
| get(Object obj) | 获得obj中对应的属性值 |
| set(Object obj, Object value) | 设置obj中对应属性值 |
（3）Method类
| 方法 | 用途 |
|---|---|
| invoke(Object obj, Object... args) | 传递object对象及参数调用该对象对应的方法 |
（4）Constructor类
| 方法 | 用途 |
|---|---|
| newInstance(Object... initargs) | 根据传递的参数创建类的对象 |
五、获取字节码文件
1. Object类的getClass()方法
对象.getClass()
多用于对象的获取字节码的方式
2. 静态属性class
类名.class
多用于参数的传递
3. Class类中静态方法forName()
class.forName("全类名")
多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
注意：在运行期间，一个类，只有一个Class对象产生。
e.g.
class Person {
String name;
Integer age;
Person() {
}
Person(String name, Integer age) {
this.name = name;
this.age = age;
}
}
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class clazz1 = Class.forName("Test.Person");
Class clazz2 = Person.class;
Class clazz3 = new Person().getClass();
System.out.println(clazz1 == clazz2); // true
System.out.println(clazz2 == clazz3); // true
System.out.println(clazz1 == clazz3); // true
}
}
六、获取构造器
| 方法 | 用途 |
|---|---|
| getConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的公有构造方法 |
| getConstructors() | 获得该类的所有公有构造方法 |
| getDeclaredConstructor(Class...<?> parameterTypes) | 获得该类中与参数类型匹配的构造方法 |
| getDeclaredConstructors() | 获得该类所有构造方法 |
获取构造器后可执行操作
| 方法 | 用途 |
|---|---|
| newInstance(Object... initargs) | 根据传递的参数创建类的对象 |
1. 获取公有的构造器
class Person {
String name;
Integer age;
Person() {
}
private Person(String name) {
super();
this.name = name;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Constructor<?>[] cons = clazz.getConstructors();
for (Constructor<?> con : cons) {
System.out.println(con);
}
System.out.println("--------");
Constructor<?> con = clazz.getConstructor(String.class, Integer.class);
System.out.println(con);
Person p = (Person) con.newInstance("zsy", 20);
System.out.println(p);
}
}
运行结果
public Test.Person(java.lang.String,java.lang.Integer)
--------
public Test.Person(java.lang.String,java.lang.Integer)
Person [name=zs, age=20]
2. 获取私有的构造器
class Person {
String name;
Integer age;
Person() {
}
private Person(String name) {
super();
this.name = name;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Constructor<?>[] cons = clazz.getDeclaredConstructors();
for (Constructor<?> con : cons) {
System.out.println(con);
}
System.out.println("--------");
Constructor<?> con = clazz.getDeclaredConstructor(String.class);
System.out.println(con);
Person p = (Person) con.newInstance("zs");
System.out.println(p);
}
}
运行结果
public Test.Person(java.lang.String,java.lang.Integer)
private Test.Person(java.lang.String)
Test.Person()
--------
private Test.Person(java.lang.String)
抛出java.lang.IllegalAccessException
会发现在使用私有构造器时会报异常
- 使用暴力反射，忽略访问权限修饰符的安全检查
class Person {
String name;
Integer age;
Person() {
}
private Person(String name) {
super();
this.name = name;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Constructor<?>[] cons = clazz.getDeclaredConstructors();
for (Constructor<?> con : cons) {
System.out.println(con);
}
System.out.println("--------");
Constructor<?> con = clazz.getDeclaredConstructor(String.class);
System.out.println(con);
con.setAccessible(true);
Person p = (Person) con.newInstance("zs");
System.out.println(p);
}
}
运行结果
public Test.Person(java.lang.String,java.lang.Integer)
private Test.Person(java.lang.String)
Test.Person()
--------
private Test.Person(java.lang.String)
Person [name=zs, age=null]
3. 获取无参构造器
class Person {
String name;
Integer age;
public Person() {
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Constructor<?> con = clazz.getConstructor();
System.out.println(con); // public Test.Person()
Person p = (Person) con.newInstance();
System.out.println(p); // Person [name=null, age=null]
}
}
获取无参构造器时，可以简化为
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Person p = (Person) clazz.newInstance();
System.out.println(p); // Person [name=null, age=null]
}
}
七、获取字段
| 方法 | 用途 |
|---|---|
| getField(String name) | 获得某个公有的属性对象 |
| getFields() | 获得所有公有的属性对象 |
| getDeclaredField(String name) | 获得某个属性对象 |
| getDeclaredFields() | 获得所有属性对象 |
获取字段后可执行操作
| 方法 | 用途 |
|---|---|
| get(Object obj) | 获得obj中对应的属性值 |
| set(Object obj, Object value) | 设置obj中对应属性值 |
1. 获取公有的字段
直接调用 clazz.getField("字段名称")
class Person {
public String name;
public Integer age;
protected String a;
String b;
private String c;
Person() {
}
Person(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Field[] fields = clazz.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("--------");
Field name = clazz.getField("name");
Field age = clazz.getField("age");
System.out.println(name);
System.out.println(age);
System.out.println("--------");
Person p = (Person) clazz.newInstance();
name.set(p, "zs");
System.out.println(name.get(p));
}
}
运行结果：
public java.lang.String Test.Person.name
public java.lang.Integer Test.Person.age
--------
public java.lang.String Test.Person.name
public java.lang.Integer Test.Person.age
--------
zs
2. 获取私有的字段
class Person {
public String name;
public Integer age;
protected String a;
String b;
private String c;
Person() {
}
Person(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("--------");
Field name = clazz.getDeclaredField("name");
Field age = clazz.getDeclaredField("age");
Field a = clazz.getDeclaredField("a");
Field b = clazz.getDeclaredField("b");
Field c = clazz.getDeclaredField("c");
System.out.println(name);
System.out.println(age);
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println("--------");
Person p = (Person) clazz.newInstance();
name.set(p, "zs");
System.out.println(name.get(p));
a.set(p, "a");
System.out.println(a.get(p));
b.set(p, "b");
System.out.println(b.get(p));
c.set(p, "c");
System.out.println(c.get(p));
}
}
运行结果：
public java.lang.String Test.Person.name
public java.lang.Integer Test.Person.age
protected java.lang.String Test.Person.a
java.lang.String Test.Person.b
private java.lang.String Test.Person.c
--------
public java.lang.String Test.Person.name
public java.lang.Integer Test.Person.age
protected java.lang.String Test.Person.a
java.lang.String Test.Person.b
private java.lang.String Test.Person.c
--------
zs
a
b
抛出java.lang.IllegalAccessException
会发现在调用和设置私有字段时会报异常
- 使用暴力反射，忽略访问权限修饰符的安全检查
class Person {
private String c;
Person() {
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Field c = clazz.getDeclaredField("c");
System.out.println(c); // private java.lang.String Test.Person.c
Person p = (Person) clazz.newInstance();
c.setAccessible(true);
c.set(p, "c");
System.out.println(c.get(p)); // C
}
}
八、获取方法
| 方法 | 用途 |
|---|---|
| getMethod(String name, Class...<?> parameterTypes) | 获得该类某个公有的方法 |
| getMethods() | 获得该类所有公有的方法 |
| getDeclaredMethod(String name, Class...<?> parameterTypes) | 获得该类某个方法 |
| getDeclaredMethods() | 获得该类所有方法 |
获取方法后可执行操作
| 方法 | 用途 |
|---|---|
| invoke(Object obj, Object... args) | 传递object对象及参数调用该对象对应的方法 |
1. 获取公有的方法
class Person {
String name;
public void eat(String str) {
System.out.println(name + "在吃" + str);
}
public void work() {
System.out.println(name + "在工作");
}
private void walk() {
System.out.println(name + "在行走");
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Person p = (Person) clazz.newInstance();
p.name = "张三";
Method method = clazz.getMethod("work");
method.invoke(p); // 张三在工作
}
}
2. 获取私有的方法
类似的，使用暴力反射，忽略访问权限修饰符的安全检查
class Person {
String name;
public void eat(String str) {
System.out.println(name + "在吃" + str);
}
public void work() {
System.out.println(name + "在工作");
}
private void walk() {
System.out.println(name + "在行走");
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Person p = (Person) clazz.newInstance();
p.name = "张三";
Method method = clazz.getDeclaredMethod("walk");
method.setAccessible(true);
method.invoke(p); // 张三在行走
}
}
3. 获取有参的方法
class Person {
String name;
public void eat(String str) {
System.out.println(name + "在吃" + str);
}
}
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取字节码
Class<?> clazz = Class.forName("Test.Person");
Person p = (Person) clazz.newInstance();
p.name = "张三";
Method method = clazz.getMethod("eat", String.class);
method.invoke(p, "苹果"); // 张三在吃苹果
}
}
九、反射实例
设计一个可以创建任意类的对象，执行此对象中任意方法的框架。
public class Student {
public String name = "zs";
public void study() {
System.out.println(name + "在学习");
}
public void eat(String str) {
System.out.println(name + "在吃" + str);
}
public void parents(String father, String mother) {
System.out.println(name + "的父亲是：" + father);
System.out.println(name + "的母亲是：" + mother);
}
}
public class Test {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
InputStream ins = Test.class.getClassLoader().getResourceAsStream("Test/pro.properties");
props.load(ins);
ins.close();
String className = props.getProperty("className");
String methodName = props.getProperty("methodName");
String methodArgs = props.getProperty("methodArgs");
String[] argList = methodArgs.isEmpty() ? null : methodArgs.split(",");
Class<?> clazz = Class.forName(className);
Object object = clazz.newInstance();
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if(method.getName().equals(methodName)) {
method.invoke(object, argList);
}
}
}
}
className=Test.Student
methodName=parents
methodArgs=ls,ww
加载配置文件
配置文件放置位置
一、通过文件路径加载
该方式必须知道文件的真实路径。
public class Test {
public static void main(String[] args) throws Exception {
String aName = getProperties("a.properties");
String bName = getProperties("src/b.properties");
String cName = getProperties("src/Test/file/c.properties");
System.out.print(aName + "\n" + bName + "\n" + cName);
}
public static String getProperties(String path) throws Exception {
InputStream ins = new FileInputStream(path);
Properties props = new Properties();
props.load(ins);
ins.close();
String className = props.getProperty("className");
return className;
}
}
二、通过getResourceAsStream加载
（1）获取src下的指定资源
Class.getResourceAsStream(String path)
path 不以’/'开头时默认是从此类所在的包下取资源
path 以’/'开头则是从ClassPath根下（即'/'代表src）获取
其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。
a.在同级目录下
有类me.class，同时在同级目录下有资源文件 myfile.properties，则应使用：me.class.getResource("myfile.properties");
b.在子目录下
com.x.y 下有类me.class，同时在子目录 com.x.y.file 下有资源文件 myfile.properties，则应使用：me.class.getResource("file/myfile.properties");
c.不在同级目录和子目录下
com.x.y 下有类me.class，同时在 com.x.file 目录下有资源文件 myfile.properties ，则应使用：me.class.getResource("/com/x/file/myfile.properties");
public class Test {
public static void main(String[] args) throws Exception {
//String aName = getProperties("a.properties"); // 这里a不在src下，不能获取
String bName = getProperties("../b.properties"); // 相对路径
String cName = getProperties("/Test/file/c.properties"); // 绝对路径
System.out.print(bName + "\n" + cName);
}
public static String getProperties(String path) throws Exception {
// getResource 获取资源的绝对路径
URL url = Test.class.getResource(path);
System.out.println(url);
// getResourceAsStream 获取资源的字节流
InputStream ins = Test.class.getResourceAsStream(path);
Properties props = new Properties();
props.load(ins);
ins.close();
String className = props.getProperty("className");
return className;
}
}
（2）获取web项目下的指定资源
ServletContext.getResourceAsStream(String path)
默认从WebAPP根目录(即:要发布在服务器下的项目的根目录(与src同级的web文件夹下))下取资源
path是否以’/'开头无所谓。 例：
在web项目的根目录下有myfile.xml文件，则应该使用
getServleContext().getResourceAsStream("myfile.xml");
三、通过类加载的方式进行加载
Class.getClassLoader().getResourceAsStream(String path)
- 默认则是从ClassPath根下获取，path不能以’/'开头，最终是由ClassLoader获取资源。
a.不在同级目录和子目录下
com.x.y 下有类me.class，同时在 com.x.file 目录下有资源文件 myfile.properties ，则应使用：me.class.getClassLoader().getResourceAsStream("com/x/file/myfile.properties");
public class Test {
public static void main(String[] args) throws Exception {
//String aName = getProperties("a.properties"); // 这里a不在src下，不能获取
String bName = getProperties("b.properties");
String cName = getProperties("Test/file/c.properties");
System.out.print(bName + "\n" + cName);
}
public static String getProperties(String path) throws Exception {
// getResource 获取资源的绝对路径
URL url = Test.class.getClassLoader().getResource(path);
System.out.println(url);
// getResourceAsStream 获取资源的字节流
InputStream ins = Test.class.getClassLoader().getResourceAsStream(path);
Properties props = new Properties();
props.load(ins);
ins.close();
String className = props.getProperty("className");
return className;
}
}
四、通过基名
文件必须是 key=value 的properties文件
public class Test {
public static void main(String[] args) throws Exception {
//String aName = getProperties("a"); // 这里a不在src下，不能获取
String bName = getProperties("b");
String cName = getProperties("Test/file/c");
System.out.print(bName + "\n" + cName);
}
public static String getProperties(String path) throws Exception {
ResourceBundle bundle = ResourceBundle.getBundle(path);
String className = bundle.getString("className");
return className;
}
}
注解
- 注解：说明程序的。给计算机看的。
- 注释：用文字描述程序的。给程序员看的。
定义
注解（Annotation），也叫元数据，一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。通过 @注解名称 来使用。
作用分类
（1）编写文档：通过代码里标识的注解生成文档【生成DOC文档（javadoc 命令）】
（2）代码分析：通过代码里标识的注解对代码进行分析【使用反射】
（3）编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【override】
JDK预定的一些注解
@Override：检测被该注解标注的方法是否是继承（实现）自父类（接口）的。
@Deprecated：该注解标注的内容表示已过时
@SuppressWarnings：压制警告，一般传递参数 all，@SuppressWarnings("all")
自定义注解
注解的格式
元注解
public @interface 注解名称 {
}
注解的本质
注解本质上就是一个接口，该接口默认继承 Annotation 接口
public interface MyAnno extends Annotation {
}
注解的属性
注解的属性就是接口中的抽象方法。
（1）属性的返回值类型有要求：有下列取值：
- 基本数据类型
- String
- 枚举
- 注解
- 以上类型的数组
（2）定义了属性，在使用时需要给属性赋值。
- 如果定义属性时，使用default关键字给属性默认初始值，则使用注解时可以不进行属性的赋值。
public @interface MyAnno {
int age();
String name() default "zs";
}
@MyAnno(age = 10)
public class Test {
public static void main(String[] args) {
}
}
- 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接写属性值即可。
public @interface MyAnno {
int value();
}
@MyAnno(12)
public class Test {
public static void main(String[] args) {
}
}
元注解
用于描述注解的注解
（1）@Target：描述注解能够作用的位置
源码：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
// 返回可应用注释类型的元素种类的数组。
ElementType[] value();
}
| 取值 | 可应用的元素 |
|---|---|
| ElementType.TYPE | 接口、类、枚举、注解 |
| ElementType.FIELD | 字段、枚举的常量 |
| ElementType.METHOD | 方法 |
| ElementType.PARAMETER | 方法参数 |
| ElementType.CONSTRUCTOR | 构造函数 |
| ElementType.LOCAL_VARIABLE | 局部变量 |
| ElementType.ANNOTATION_TYPE | 注解 |
| ElementType.PACKAGE | 包 |
（2）@Retention：描述注解被保留的阶段
源码：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
// 返回保留策略。
RetentionPolicy value();
}
| 取值 | 说明 |
|---|---|
| RetentionPolicy.SOURCE | 注解仅存在于源码中，在class字节码文件中不包含 |
| RetentionPolicy.CLASS | 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得 |
| RetentionPolicy.RUNTIME | 注解会在class字节码文件中存在，在运行时可以通过反射获取到 |
首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作用的地方后者一定也能作用。
- 一般如果需要在运行时去动态获取注解信息，那只能用 RUNTIME 注解；
- 如果要在编译时进行一些预处理操作，比如生成一些辅助代码（如 ButterKnife），就用 CLASS注解；
- 如果只是做一些检查性的操作，比如 @Override 和 @SuppressWarnings，则可选用 SOURCE 注解。
（3）@Documented：描述数据是否被抽取到API文档中
（3）@Inherited：描述注解是否被子类继承
注解的解析
注解通过反射获取。首先可以通过 Class 对象的 isAnnotationPresent() 方法判断它是否应用了某个注解。
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}
然后通过 getAnnotation() 方法来获取指定类型的Annotation 对象。或者是 getAnnotations() 方法获取注解到这个元素上的所有 Annotation 对象。
public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}
public Annotation[] getAnnotations() {}
如果获取到的 Annotation 如果不为 null，则就可以调用它们的属性方法了。
@MyAnno(age = 10, name = "zs")
public class Test {
public static void main(String[] args) {
// 获取该类字节码对象
Class<Test> clazz = Test.class;
// 获取上边注解对象
boolean hasAnno = clazz.isAnnotationPresent(MyAnno.class);
if (hasAnno) {
MyAnno anno = clazz.getAnnotation(MyAnno.class);
int age = anno.age();
String name = anno.name();
System.out.println(age);
System.out.println(name);
}
}
}
Java 面向对象（十四）的更多相关文章
- “全栈2019”Java第九十四章：局部内部类详解
难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...
- “全栈2019”Java第十四章：二进制、八进制、十六进制
难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...
- “全栈2019”Java第二十四章：流程控制语句中决策语句switch下篇
难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...
- JavaSE学习总结（四）——Java面向对象十分钟入门
面向对象编程(Object Oriented Programming,OOP)是一种计算机模拟人类的自然思维方式的编程架构技术,解决了传统结构化开发方法中客观世界描述工具与软件结构的不一致性问题.Ja ...
- java面向对象中四种权限（private，protected，public，友好型）详解
转自http://blog.csdn.net/a1237871112/article/details/50926975 及http://blog.csdn.net/blackmanren/articl ...
- java 面向对象（四十二）：反射（六）反射应用三：调用运行时类的指定结构
调用指定的属性: @Test public void testField1() throws Exception { Class clazz = Person.class; //创建运行时类的对象 P ...
- java 面向对象（四十）：反射（四）反射应用一：创建运行时类的对象
1.代码举例Class<Person> clazz = Person.class; Person obj = clazz.newInstance();System.out.println( ...
- 菜鸟学Java（十四）——Java反射机制（一）
说到反射,相信有过编程经验的人都不会陌生.反射机制让Java变得更加的灵活.反射机制在Java的众多特性中是非常重要的一个.下面就让我们一点一点了解它是怎么一回事. 什么是反射 在运行状态中,对于任意 ...
- java面向对象编程(四)--类变量、类方法
1.什么是类变量? 类变量是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量. 如何定义类变量? 定义语法: ...
- Java基础(十四)--装箱、拆箱详解
Java中基本数据类型都有相对应的包装类 什么是装箱?什么是拆箱? 在Java SE5之前,Integer是这样初始化的 Integer i = new Integer(10); 而在从Java SE ...
随机推荐
- js 单引号和双引号相互替换的实现方法
1.双引号替换成单引号 var domo = JSON.stringify(address).replace(/\"/g,"'"); var a = {a:1,b:2}; ...
- arm-none-eabi/bin/ld: build/com.zubax.gnss.elf section `.text' will not fit in region `flash'
出现如下错误: /arm-none-eabi/bin/ld: build/com.zubax.gnss.elf section `.text' will not fit in region `flas ...
- Eclipse 交叉编译环境
创建空工程 添加交叉编译环境 添加工程文件 如需修改交叉编译环境 Cross GCC:使用交叉编译命令编译,需要自己指定 MinGW GCC:使用make命令编译,需要有Makefile Make T ...
- [LeetCode] 342. 4的幂 ☆(是否4 的幂)
描述 给定一个整数 (32 位有符号整数),请编写一个函数来判断它是否是 4 的幂次方. 示例 1: 输入: 16输出: true示例 2: 输入: 5输出: false 进阶:你能不使用循环或者递归 ...
- Windows如何打开/关闭 服务
先右键Windows主菜单,点击计算机管理: 点击服务和应用程序: 点击服务:
- Windows下静态库的制作与使用
参考 静态链接 VS 动态链接 静态库 VS 动态库 实验环境 OS:Windows10 企业版 IDE:Visual Studio 2017旗舰版 前言 静态链接库与动态链接库都是共享代码的方式,如 ...
- bloomberg bulkfile【一】 文件的分类
文章导航 bloomberg bulkfile [一] 文件的分类 bloomberg bulkfile [二] 文件解析 bloomberg bulkfile [三] 在oracle的存储 订 ...
- JS控制SVG缩放+鼠标控制事件
话不多说,直接上代码吧,不行你砍我... <!DOCTYPE html> <html lang="en"> <head> <meta ch ...
- mysql官方下载安装教程（centos）
Linux下Mysql 5.6.30 tar包安装 (2016-04-27 22:45:39) 转载▼ 环境:centos 6.4 x64 先下载mysql安装包 打开 http://dev.mysq ...
- springboot项目对接支付宝支付
支付宝对接文档 一.准备工作 1. 首先要到 蚂蚁金服开发者中心 https://openhome.alipay.com/platform/home.htm 注册商家账户,并认证. 2.下载java版 ...