注解和反射
1 什么是注解
- Annotation是从JDK5.0开始引入的新技术
- Annotation的作用:
- 可以对程序作出解释,这一点和注释comment类似
- 对程序进行检查和约束,例如@Override
- 可以被其他程序(比如:编译器等)读取
- Annotation的格式:
- 注解是以“@注释名”在代码中存在的,还可以添加一些参数值,例如:@SuppressWarning(value=”unchecked”)
- Annotation在哪里使用?
- 可以附加在package、class、method、field等上面,相等于给他们添加了额外的辅助信息,然后结合反射机制实现对这些元数据的访问。
2 内置注解
2.1 内置注解
- @Override:
- 定义在java.lang包中,此注解只适用于修饰方法,表示该方法打算重写父类中的同名方法,并且具有检查作用
class BuyTickets implements Runnable{
@Override
public void run() {
System.out.println("这里是重写的方法");
}
}
- @Deprecated:
- 定义在java.lang包中,此注释可以修饰方法、属性、类,注释
- @Deprecated的程序元素是程序员不鼓励使用的程序元素,通常是因为它是危险的,或者因为它已经过时了,然后存在更好的替代方法,但是你使用也没有任何影响,使用案例如下:
@Deprecated
public void test1(){
System.out.println("这是不推荐再使用的方法");
}
- @SupressWarnings:定义在java.lang包中,用来抑制编译时产生的黄色警告信息,虽然这些警告信息不会影响编译结果,但是看着不舒服,然后该注释和前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的,具体参数信息如下所示:
- @SuppressWarnings(“all”) // 压制所有警告,下面有例子:
- @SuppressWarnings(“unchecked”) // 压制"unchecked"警告
- @SuppressWarnings(value={“unchecked”, “deprecation”}) // 压制"unchecked", "deprecation"警告
@SuppressWarnings("all")
public void test2(){
ArrayList<> objects = new ArrayList<>();
}
注意:
- public @interface SuppressWarnings {String[] value();},其中value是参数名,而String[]是参数是类型,当注解只使用value这一个参数的时候,value可以省略,例如上面的@SuppressWarnings(“all”)和@SuppressWarnings(“unchecked”)就是省略了前面的value,但是仅限参数名是value,并且注解中只使用value这一个参数的情况才可以 省略value
package com.xibukaiyuan.reflection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class TestAnnotate {
public static void main(String[] args) {
}
@MyAnnotation2("")
public void test1(){
}
}
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
String[] name();
}
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
String value();
}
3 什么是元注解
3.1 元注解
- 元注解作用:
- 负责注解其他注解,Java中定义了4个标准的元注解()类型,他们被用来对其他注解类型进行解释说明限制
- 元注解位置:
- 在java.lang.annotation包中
3.2 元注解四大类型
- @Target:用于描述注解的使用范围,也就是描述注解可以使用在什么地方,
public @interface Target {ElementType[] value();}
可以看出可以它是一个数组,可以有多个值,里面的值设置的都是定义的注解MyAnnotation的使用范围,比如在类上、方法上等等,你可以通过@Target,然后点击里面的ElementType去查看
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
String[] name();
}
12345
public enum ElementType {
/** Class, interface (including annotation type), or enum declaration */
TYPE,
/** Field declaration (includes enum constants) */
FIELD,
/** Method declaration */
METHOD,
/** Formal parameter declaration */
PARAMETER,
/** Constructor declaration */
CONSTRUCTOR,
/** Local variable declaration */
LOCAL_VARIABLE,
/** Annotation type declaration */
ANNOTATION_TYPE,
/** Package declaration */
PACKAGE,
/**
* Type parameter declaration
*
* @since 1.8
*/
TYPE_PARAMETER,
/**
* Use of a type
*
* @since 1.8
*/
TYPE_USE
}
@Retention:表示需要在什么级别保存该注释信息,用于描述注解的生命周期(SOURCE < CLASS < RUNTIME),SOURCE是源码级别,CLASS 是源码级别和编译之后的字节码文件中有效,RUNTIME是在源码级别、编译之后的字节码文件、JVM中运行都有效,最常用的就是RUNTIME
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
String value();
}
@Documented:说明该注解将被包含在javadoc文档中
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@interface MyAnnotation3{
String name() default "cat";
}
@Inherited:说明子类可以继承父类中的该注解
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface MyAnnotation3{
String name() default "cat";
}
4 自定义注解
-
使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口
-
@interface 用来声明一个注解,格式是:
修饰符 @interface 注解名{定义内容}
- 内容中的每一个方法实际上是声明了一个配置参数,方法的名称就是参数的名称,方法的返回值类型就是参数的类型
- 返回值类型只能是基本类型、Class、String、enum,如果返回值是String[]的时候,赋值的时候要用{“X1”, “X2”}这种形式,见:
MyAnnotation
- 可以通过default来声明参数的默认值,声明默认值的可以不在自定义注解中赋值,反之必须赋值。见:
MyAnnotation3
- 如果只有一个参数成员,一般参数名使用value字段,这是因为当参数名称是value并且自定义注解中只需要写一个参数的时候,可以省略参数名称,只有value可以这样,其他的都不行。见:
MyAnnotation2
- 注解元素必须有值,我们定义注解元素时,经常使用空字符串、0、-1等作为默认值,当默认值为-1,代表不存在
package com.xibukaiyuan.reflection;
import java.lang.annotation.*;
public class TestAnnotate {
public static void main(String[] args) {
}
@MyAnnotation(name={"a","b"})
@MyAnnotation2("a")
@MyAnnotation3
public void test1(){
}
}
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation{
String[] name();
}
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation2{
String value();
}
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface MyAnnotation3{
String name() default "cat";
}
5 反射概述
- Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,并且能直接操作任意对象的内部属性以及方法。
- 加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构,这个对象就像一面镜子,透过这个镜子可以看到类的结构,这就是反射。
6 获取反射对象
6.1 反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
- ……
6.2 反射相关的主要API
- java.lang.Class:代表一个类,它就是Object类getClass()方法的返回值,它是唯一的所以类都指向它
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
- ……
6.3 反射初体验
package com.xibukaiyuan.reflection;
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException {
Cat cat = new Cat();
Class c1 = Class.forName("com.xibukaiyuan.reflection.Cat");
Class c2 = Class.forName("com.xibukaiyuan.reflection.Cat");
//同一个类只有一个Class对象
System.out.println(c1.hashCode()==c2.hashCode());
}
}
class Cat{
private String name;
}
class Dog{
private String name;
}
12345678910111213141516171819
6.4 Class类详解
7 得到Class类的几种方式
7.1 Class类
- Class本身也是一个类,不过这个类只有一个,所有的类都执行它,例如User类、Person类等
- Class对象是Class类的对象,一个加载的类(例如User.java)在JVM中只会有一个Class对象
- 一个Class对象对应的是一个加载到JVM中的对应的XXX.class文件
- 每个类(例如User.java)的实例(例如User u = new User()中的u)都会记着自己是由哪个Class对象所生成
- 通过CLass对象可以完整地得到一个类(例如User.java)中所有被加载的信息
- Class类(只有一个,和Object类中getClass()方法中返回的Class是同一个)是Reflection的根源,针对任何你想动态加载、运行的类、唯有先获得类(例如User.java)对应的Class对象
- 以上说了三个部分:Class类、Class对象、类、类的实例,通过类可以创建类的实例,通过Class类可以获取某类的Class对象,通过Class对象可以获取类中的所有信息(方法、属性等等),当然也可以创建类的实例,另外Class对象是类具有的,类可以做的它也能做
7.2 Class类的常用方法
7.3 获取Class类的实例
package com.xibukaiyuan.reflection;
import java.lang.reflect.Constructor;
public class TestReflection1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
//通过类的class属性获取,该方法最为安全可靠,程序性能最高
Class c1 = Horse.class;
System.out.println(c1);
//通过类的实例中的getClass()方法获取
Horse horse = new Horse();
Class c2 = horse.getClass();
System.out.println(c2);
//通过类的全限定类名获取
Class c3 = Class.forName("com.xibukaiyuan.reflection.Horse");
System.out.println(c3);
//通过基本内置类型的包装类的Type属性(了解)
//int
Class c4 = Integer.TYPE;
System.out.println(c4);
//通过ClassLoader类加载器获取
Class c5 = c1.getDeclaredConstructor(null).getDeclaringClass();
System.out.println(c5);
}
}
class Horse{
}
1234567891011121314151617181920212223242526272829303132
7.4 其他
- 获取父类类型
Class c6 = c1.getSuperclass();
System.out.println(c6);
12
- 获取Duck对象
Duck duck1 = (Duck) c1.newInstance();
System.out.println(duck1);
12
- 使用构造器创建Duck对象
Duck duck2 = (Duck) c1.getDeclaredConstructor(null).newInstance(null);
System.out.println(duck2);
12
- 通过反射调用普通方法
Duck duck3 = (Duck) c1.newInstance();
//单一参数的函数的调用方法:
//方法名.invoke(对象名,方法参数)
Method run = c1.getDeclaredMethod("run", String.class);
run.invoke(duck3,"100");
//空参函数的调用方法:
//方法名.invoke(对象名,null)
Method eat = c1.getDeclaredMethod("eat", null);
eat.invoke(duck3,null);
//多参函数的调用方法:
//方法名.invoke(对象名,null)
Method drink = c1.getDeclaredMethod("drink", String.class, String.class);
drink.invoke(duck3,"呱呱","苹果汁");
12345678910111213141516
- 通过反射给属性赋值
Field name = c1.getDeclaredField("name");
name.setAccessible(true);
name.set(duck3,"呱呱");
System.out.println("鸭子的名字叫"+duck3.getName());
1234
8 所有类型的Class对象
8.1 具有CLass对象的类型
- class:外部类、成员内部类和静态内部类、局部内部类、匿名内部类
Class c1 = Object.class;
1
Class c4 = ArrayList.class;
1
- interface:接口
Class c2 = Runnable.class;
1
- []:数组
Class c3 = Integer[].class;
1
- enum:枚举
//class java.lang.annotation.ElementType
Class c5 = ElementType.class;
12
- annotation:注解
//interface java.lang.Override
Class c6 = Override.class;
System.out.println(c6);
123
- 基本内置类型的包装类,例如Integer等
//short
Class c7 =short.class;
System.out.println(c7);
//class java.lang.Short
Class c8 =Short.class;
System.out.println(c8);
1234567
- void
//class java.lang.Void
Class c9 = Void.class;
System.out.println(c9);
123
- Class类
//class java.lang.Class
Class c10 = Class.class;
System.out.println(c10);
123
8.2 元素类型、维度和Class对象的关系
- 元素类型相同,维度相同,但是具体内容不同,Class对象相同
//class [I
Class c1 = int[].class;
int[] ints1 = new int[10];
int[] ints2 = new int[100];
System.out.println(c1.hashCode()); //1639705018
System.out.println(ints1.getClass().hashCode()); //1639705018
System.out.println(ints2.getClass().hashCode()); //1639705018
12345678
- 元素类型相同,但是维度不同,Class对象不同
//class [I
Class c1 = int[].class;
//class [[I
Class c2 = int[][].class;
//[Ljava.lang.String;
Class c3 = String[].class;
System.out.println(c1.hashCode()); //1639705018
System.out.println(c2.hashCode()); //1627674070
System.out.println(c3.hashCode()); //1360875712
123456789
- 元素类型不同,Class对象不同
//class [I
Class c1 = int[].class;
//[Ljava.lang.String;
Class c3 = String[].class;
System.out.println(c1.hashCode()); //1639705018
System.out.println(c3.hashCode()); //1627674070
123456
9 性能对比分析
package com.xibukaiyuan.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestReflection3 {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Fruit fruit1 = new Fruit();
long s1 = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
fruit1.getColor();
}
long e1 = System.currentTimeMillis();
//普通方式调用方法耗时8
System.out.println("普通方式调用方法耗时"+(e1-s1));
Method getColor = Fruit.class.getDeclaredMethod("getColor", null);
long s2 = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getColor.invoke(fruit1,null);
}
long e2 = System.currentTimeMillis();
//反射方式调用方法耗时4202
System.out.println("反射方式调用方法耗时"+(e2-s2));
}
}
class Fruit{
String color;
public String getColor() {
return color;
}
}