注解与反射

一、注解

1、概念

注解（也被称为元数据）为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻非常方便地使用这些数据。

2、常见注解

@Override

用于标记重写某个方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Deprecated

用于标记已经过时的方法、属性等内容

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

@SuppressWarnings

用于镇压警告

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

总结

可以看出注解有这么几个部分

  • @interface + 注解名称

  • @Target : 注解的作用域

    public enum ElementType {
    TYPE,

    FIELD,

    METHOD,

    PARAMETER,

    CONSTRUCTOR,

    LOCAL_VARIABLE,

    ANNOTATION_TYPE,

    PACKAGE,

	// JDK 8 以后添加的注解
    TYPE_PARAMETER,
    
    TYPE_USE
}

  • @Retention : 注解的生命周期

    public enum RetentionPolicy {
    SOURCE,

    CLASS,

    RUNTIME
}

3、元注解

概念

  • 元注解的目的就是注解其他注解，Java提供了4个meta-annotation，他们被用来对其他注解提供说明

  • 他们可以在 java.lang.annotation 包下被找到

注解

@Target

用于标明注解的作用范围

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

@Retention

用于标明注解的生命周期

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

@Documented

用于标明该注解将会被包含在javadoc中

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

@Inherited

用于标明子类可以继承父类的该注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

4、自定义注解

步骤

  • 通过 @interface 关键字定义注解名称。此时会自动继承 java.lang.annotation.Annotation
  • 需要给定一个或多个元注解
  • 自定义注解的参数声明方式是 ： 参数类型 参数名称 (); ，如 String name();
    • 可以定义默认值，如 String name () default = “Nyima”;
public class Demo1 {
   @MyAnnotation(name = "Main Method")
   public static void main(String[] args) {
      
   }
}

@Target(value = {ElementType.METHOD})
@Retention(value =  RetentionPolicy.RUNTIME)
@interface MyAnnotation {
   String name();
   int age() default 0;
}

二、反射

1、Java Reflection

  • Reflection 是 Java被视为动态语言（运行时改变其结构）的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

  • 加载完类之后，在对内存的方法去中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象地称之为：反射

正常方式创建对象：

  • 引入需要的包的名称
  • 通过new实例化
  • 获得实例化对象

反射方式创建对象：

  • 实例化对象
  • getClass()方法
  • 得到完整的包的名称

2、优缺点

优点

  • 可以实现动态创建对象和编译，体现出很大的灵活性
  • 对性能有所影响

3、相关API

  • java.lang.Class：代表一个类
  • java.lang.reflect.Method：代表类的方法
  • java.lang.reflect.Field：代表类的成员变量
  • java.lang.reflect.Constructor：代表类的构造器

4、使用

通过反射创建对象

获取类的Class对象有三种方法

public class Demo2 {
	public static void main(String[] args) throws ClassNotFoundException {
		// 通过反射获取多个User类的Class对象，看其是否相等
		// 通过Class类的forName()方法来获得类的Class对象
		Class c1 = Class.forName("main.study.day4.User");
		// 通过类的class属性获得Class对象
		Class c2 = User.class;
		// 通过对象的getClass()方法获得Class对象
		Class c3 = new User().getClass();
		System.out.println(c1.hashCode());
		System.out.println(c2.hashCode());
		System.out.println(c3.hashCode());
		c3.getClass();
	}
}

class User {
	private String name;
	private int age;

	public User() {
	}

	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

运行结果

1163157884
1163157884
1163157884

结论：可以看出，通过反射获取某个类的Class对象，获取的对象都是相同的。也就是每个类有且只有一个Class对象

Class类

Object类中定义以下方法

public final native Class<?> getClass();

这个方法的返回值就是Class类，Class类是反射的源头

  • Class本身也是一个类
  • Class对象只能由系统建立对象
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个 加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的对象

拥有Class对象的类型

class：外部类、内部内、静态内部类等

interface：接口

[]：数组

enum：枚举

annotation：注解@interface

primitive type：基本数据类型

void

public class Demo3 {
   public static void main(String[] args) {
      Class c1 = Object.class;
      Class c2 = Collection.class;
      Class c3 = int[].class;
      Class c4 = ElementType.class;
      Class c5 = SuppressWarnings.class;
      Class c6 = Integer.class;
      Class c7 = void.class;
   }
}

通过反射获得类的信息

public class Demo4 {
   public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException, ClassNotFoundException {
      Class c1 = Class.forName("main.study.day4.User");
      
      // 获得所有公共属性
      Field[] fields = c1.getFields();
      
      // 获得所有属性
      Field[] declaredFields = c1.getDeclaredFields();
      
      // 获得指定属性
      Field name = c1.getDeclaredField("name");

      // 获得所有公有方法
      Method[] methods = c1.getMethods();
      
      // 获得所有方法
      Method[] declaredMethods = c1.getDeclaredMethods();
      
      // 获得指定方法
      Method setAge = c1.getDeclaredMethod("setAge", int.class);
   }
}

通过反射获得类的对象

通过newInstance()方法

  • 类必须含有一个无参构造器
  • 类的构造器的访问权限要足够
public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      System.out.println(user);
   }
}

如果重载了一个方法的构造方法，最好再补上一个无参构造函数

通过获得类的构造器，再进行初始化

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class c1 = Class.forName("main.study.day4.User");
      Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
      User user2 = (User) constructor.newInstance("Nyima", 20);
      System.out.println(user2.getAge());
   }
}

总结：获得类的实例的步骤

  • 通过类的Class对象
  • 如果想通过调用无参构造方法创建实例
    • 直接调用Class对象的newInstance()方法
    • 将返回值强转为对应的类型
  • 如果想通过有参构造方法创建实例
    • 调用Class对象的getDeclaredConstructor()并传入构造方法相应的参数的类型
    • 通过获得的有参构造器，调用newInstance()方法，传入相应参数
    • 将返回值强转为对应的类型

通过反射调用类的方法

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      Method setName = c1.getDeclaredMethod("setName", String.class);
      setName.invoke(user, "Nyima");
      System.out.println(user.getName());

   }
}

步骤

  • 获得类的Class对象
  • 调用Class对象的newInstance()方法，获取类的对象
  • 调用Class对象的getDeclaredMethod()方法
  • 调用返回对象的invoke()方法，传入所需的参数（参数包含对哪个对象调用该方法），如 setName.invoke(user, “Nyima”);

通过反射设置属性值

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      Field name = c1.getDeclaredField("name");
      name.set(user, "Nyima2");
      System.out.println(user.getName());
   }
}

步骤

  • 获得类的Class对象
  • 调用Class对象的newInstance()方法，获取类的对象
  • 调用Class对象的getDeclaredField()方法，获取属性
  • 调用属性对象的set()方法进行赋值
    • 如果是私有属性，还需要调用name.setAccessible(true);方法进行设定

通过获得注解信息

public class Demo6 {
	public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException {
		Class c1 = Class.forName("main.study.day4.Student");
		Student student = (Student) c1.newInstance();
		// 获得类的注解
		Annotation[] declaredAnnotations = c1.getDeclaredAnnotations();
		System.out.println(Arrays.toString(declaredAnnotations));

		// 获得属性上的注解
		Field name = c1.getDeclaredField("name");
		Annotation annotation = name.getAnnotation(FieldAnnotation.class);
		System.out.println(annotation);

		// 获得方法的注解
		Method getName = c1.getDeclaredMethod("getName");
		MethodAnnotation methodAnnotation = getName.getAnnotation(MethodAnnotation.class);
		System.out.println(methodAnnotation);
	}
}

@ClassAnnotation(name = "myStudent")
class Student {

	@FieldAnnotation(name = "name")
	private String name;
	@FieldAnnotation(name = "age")
	private int age;

	public Student() {
	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@MethodAnnotation(name = "getName")
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 类的注解
 */
@interface ClassAnnotation {
	String name();
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 属性的注解
 */
@interface FieldAnnotation {
	String name();
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 方法的注解
 */
@interface MethodAnnotation {
	String name();
}

步骤

  • 先获取到对应的类，如
    • 想获得类注解，需要先获得Class类对象
    • 想获得属性的注解，需要先获得对应的属性
    • 想获得方法的注解，需要先获得对应的方法
    • …
  • 通过对应的对象调用getDeclaredAnnotation()或者其他获取注解的方法，并传入需要的参数即可

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！

集合源码 Previous
指令流程和中断 Next