JavaSE-单元测试、反射、注解

[TOC]

第一章：单元测试

1.1 测试分类

• 黑盒测试，不需要写代码，给输入值，看程序是否能够输出期望的值。
• 白盒测试，需要写代码的。关注程序具体的执行流程。
  • 利用java中的junit依赖环境是白盒测试的一种方式

1.2 Junit的使用步骤

1. 定义一个测试类(测试用例)
2. 定义测试方法：可以独立运行
3. 给方法加@Test
4. 导入junit依赖环境
5. 判定结果：
   • 红色：失败
   • 绿色：成功
   • 一般我们会使用断言操作来处理结果
     • Assert.assertEquals(期望的结果,运算的结果);
6. Before和After
   • @Before:
     • 修饰的方法会在测试方法之前被自动执行
   • @After:
     • 修饰的方法会在测试方法执行之后自动被执行

1.3 Junit使用

• 程序代码

  /*
  * 计算器类
  * */
  public class Calc {
    public int add(int num1,int num2){
      return num1+num2;
    }
    public int subtract(int num1,int num2){
      return num1-num2;
    }
    public int multi(int num1,int num2){
      return num1*num2;
    }
    public int div(int num1,int num2){
      return num1+num2;
    }
  }
  

• 测试代码

  package cn.leilei.junitTest;
  
  import cn.leilei.junitDemo.Calc;
  import org.junit.After;
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  
  public class CalcTest {
    private Calc calc;
    // 测试之前会执行的代码
    @Before
    public void init(){
      calc = new Calc();
    }
    @Test
    public void addTest(){
      int num = calc.add(10,20);
      // 断言结果和计算结果判定
      Assert.assertEquals(30,num);
    }
    @Test
    public void subtractTest(){
      int num = calc.subtract(10,20);
      Assert.assertEquals(-10,num);
    }
    @Test
    public void multiTest(){
      int num = calc.multi(10,20);
      Assert.assertEquals(200,num);
    }
    @Test
    public void divTest(){
      int num = calc.div(20,10);
      Assert.assertEquals(2,num);
    }
    // 测试完毕后会执行的方法
    @After
    public  void  after(){
      System.out.println("程序测试完毕");
    }
  
  }
  
  

• 结果

  • 绿色标识，测试通过
  • 红色标识，测试异常

第二章：反射

2.1 反射介绍

​Java反射机制指的是在Java程序运行状态中，对于任何一个类，都可以获得这个类的所有属性和方法；对于给定的一个对象，都能够调用它的任意一个属性和方法。这种动态获取类的内容以及动态调用对象的方法称为反射机制。

​Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制。

2.2 反射的好处

​首先，反射机制极大的提高了程序的灵活性和扩展性，降低模块的耦合性，提高自身的适应能力。

​其次，通过反射机制可以让程序创建和控制任何类的对象，无需提前硬编码目标类。

​再次，使用反射机制能够在运行时构造一个类的对象、判断一个类所具有的成员变量和方法、调用一个对象的方法。

​最后，反射机制是构建框架技术的基础所在，使用反射可以避免将代码写死在框架中。

​正是反射有以上的特征，所以它能动态编译和创建对象，极大的激发了编程语言的灵活性，强化了多态的特性，进一步提升了面向对象编程的抽象能力，因而受到编程界的青睐

2.3 反射的缺点

反射机制的功能非常强大，但不能滥用。在能不使用反射完成时，尽量不要使用，原因有以下几点：

1、性能问题。

Java反射机制中包含了一些动态类型，所以Java虚拟机不能够对这些动态代码进行优化。因此，反射操作的效率要比正常操作效率低很多。我们应该避免在对性能要求很高的程序或经常被执行的代码中使用反射。而且，如何使用反射决定了性能的高低。如果它作为程序中较少运行的部分，性能将不会成为一个问题。

2、安全限制。

使用反射通常需要程序的运行没有安全方面的限制。如果一个程序对安全性提出要求，则最好不要使用反射。

3、程序健壮性。

反射允许代码执行一些通常不被允许的操作，所以使用反射有可能会导致意想不到的后果。反射代码破坏了Java程序结构的抽象性，所以当程序运行的平台发生变化的时候，由于抽象的逻辑结构不能被识别，代码产生的效果与之前会产生差异。

2.4 在Java中使用反射机制

1. 获取Class对象的方式

• 获取方式

  1. Class.forName("全类名")，将字节码文件加载进内存，返回Class对象
  2. 类名.class，通过类名的属性class获取
  3. 对象.getClass()：getClass()方法在Object类中定义着

• 代码

  • Person类

    public class Person {
      private String name;
      private int age;
      private boolean gender;
      public int height;
      public Person(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
      }
      public Person() {
      }
      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;
      }
      public boolean isGender() {
        return gender;
      }
      public void setGender(boolean gender) {
        this.gender = gender;
      }
      public void eat(){
        System.out.println("吃....");
      }
      public void eat(String food){
        System.out.println("吃"+food);
      }
    }
    
    

  • Test01类

    
    public class Test01 {
      public static void main(String[] args) throws Exception {
        // 方式1
        Class cls = Class.forName("cn.leilei.reflect.Person");
        // 方式2
        Class cls2 = Person.class;
        // 方式3
        Class cls3 = new Person().getClass();
        System.out.println(cls==cls2); // true
        System.out.println(cls==cls3); // true
        // 三种方式获取的都是同一个Class类型对象
      }
    }
    

2. Class对象功能-获取成员变量

• 获取成员变量的方式

  • Field[] getFields() ：获取所有public修饰的成员变量
  • Field getField(String name) 获取指定名称的 public修饰的成员变量
  • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
  • Field getDeclaredField(String name) 获取指定名称的成员变量，不考虑修饰符

• 成员变量相关操作

  1. 设置值
     • void set(Object obj, Object value)
  2. 获取值
     • get(Object obj)
  3. 忽略访问权限修饰符的安全检查
     • setAccessible(true):暴力反射

• 代码

  public class Test02 {
    public static void main(String[] args) throws Exception {
      // 【动态加载本地字节码文件，并获取Person的Class对象】
      Class cls = Class.forName("cn.leilei.reflect.Person");
  
      // 【获取成员变量】
      Field[]fields =  cls.getFields();
      System.out.println(Arrays.toString(fields));// [public int cn.leilei.reflect.Person.height]只获取了一个权限是public修饰的成员变量
      Field[]fields2 = cls.getDeclaredFields();
      System.out.println(Arrays.toString(fields2)); // [private java.lang.String cn.leilei.reflect.Person.name, private int cn.leilei.reflect.Person.age, public int cn.leilei.reflect.Person.height, private boolean cn.leilei.reflect.Person.gender] 获取的所有的成员变量，不受修饰符的影响
      Field field = cls.getField("height");
      System.out.println(field);
      Field field2 = cls.getDeclaredField("age"); // public int cn.leilei.reflect.Person.height  受修饰符的影响
      System.out.println(field2);// private int cn.leilei.reflect.Person.age 不受修饰符的影响
  
      // 【获取一个成员的值】
      Person p = new Person();
      // 忽略访问权限修饰符的安全检查
      field2.setAccessible(true);
      System.out.println(field2.get(p));  //0
  
      // 【设置一个成员的值】
      field2.set(p,18);
      System.out.println(p.getAge()); // 18
  
  
    }
  }
  

3. Class对象功能-获取构造方法

• 获取方式

  • Constructor<?>[] getConstructors()
  • Constructor<T> getConstructor(类<?>... parameterTypes)
  • Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
  • Constructor<?>[] getDeclaredConstructors()

• 构造方法相关操作-创建实例对象

  • T newInstance(Object... initargs)
  • 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

• 代码

  public class Test03 {
    public static void main(String[] args) throws Exception {
      // 【导入本地Person的字节码文件，获取对应的Class对象】
      Class cls = Class.forName("cn.leilei.reflect.Person");
      // 【获取构造函数】
      // 获取Class对象中的所有构造函数
      Constructor[]cs = cls.getConstructors();
      System.out.println(Arrays.toString(cs)); // [public cn.leilei.reflect.Person(java.lang.String,int,boolean), public cn.leilei.reflect.Person()]
      // 获取Class对象中指定的带参数构造函数
      Constructor csParam = cls.getConstructor(String.class,int.class,boolean.class);
      System.out.println(csParam); // public cn.leilei.reflect.Person(java.lang.String,int,boolean)
      // 获取Class对象中指定的无带参数构造函数
      Constructor csNoParam = cls.getConstructor();
      System.out.println(csNoParam); // public cn.leilei.reflect.Person()
      // 【操作构造函数-创建对象】
      Person p = (Person) csParam.newInstance("张三",10,true);
      System.out.println(p); //name:张三,age:10,gender:true
      Person p1 = (Person)csNoParam.newInstance();  // 创建无参数对象，和cls.newInstance()等效
      System.out.println(p1); // name:null,age:0,gender:false
    }
  }
  

4. Class对象功能-获取成员方法

• 获取方式

  • Method[] getMethods()
  • Method getMethod(String name, 类<?>... parameterTypes)
  • Method[] getDeclaredMethods()
  • Method getDeclaredMethod(String name, 类<?>... parameterTypes)

• 成员方法的相关操作

  • Object invoke(Object obj, Object... args) 执行方法
  • String getName():获取方法名

• 代码

  public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
      // 【获取Person的Class对象】
      Class<Person> cls = (Class<Person>)Class.forName("cn.leilei.reflect.Person");
      // 【获取有参的构造函数】
      Constructor cons = cls.getConstructor(String.class,int.class,boolean.class);
      // 【创建实例对象】
      Person p = (Person) cons.newInstance("张三",10,true);
      // 【获取指定的方法-带有字符串参数】
      Method eatMethond = cls.getMethod("eat",String.class);
      //【执行方法】
      eatMethond.invoke(p,"鸡蛋"); // 吃鸡蛋
      // 【获取指定的方法-无参数】
      Method eatMethond2 = cls.getMethod("eat");
      //【执行方法】
      eatMethond2.invoke(p); // 吃...
      System.out.println(eatMethond.getName()); // eat 获取方法名
    }
  }
  

5. Class对象功能-获取全类名

• 获取方式

  • String getName()

• 代码

  public class Test05 {
    public static void main(String[] args) throws Exception {
      // 【获取Person的Class对象】
      Class<Person> cls = (Class<Person>)Class.forName("cn.leilei.reflect.Person");
      System.out.println(cls.getName()); // cn.leilei.reflect.Person
    }
  }
  

2.5 反射案例-体验反射灵活性

• 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中

• 实现：配置文件 + 反射

• 分析

  1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
  2. 在程序中加载读取配置文件
  3. 使用反射技术来加载类文件进内存
  4. 创建对象
  5. 执行方法

• 代码

  • 配置文件

    className=cn.leilei.reflect.Person
    methondName=eat
    

  • 反射代码

    public class Test06 {
      public static void main(String[] args) throws Exception {
        // 获取类加载器
        ClassLoader loader = Test06.class.getClassLoader();
        // 使用类加载器获取配置文件的文件流
        InputStream is = loader.getResourceAsStream("test.properties");
        // 创建Properties集合-存放配置信息
        Properties map = new Properties();
        map.load(is);
        // 根据配置信息，获取要使用的类对应的字节码对象
        Class cs = Class.forName(map.getProperty("className"));
        // 获取无参数的构造函数并创建对象
        Object obj = cs.getConstructor().newInstance();
        // 根据配置信息，获取要执行的指定的方法
        Method method = cs.getMethod(map.getProperty("methondName"));
        // 执行方法
        method.invoke(obj);
    
    
      }
    }
    

• 好处

  • 不修改“框架”的源码，仅更改配置文件满足不同的对象创建和方法调用

第三章：注解

3.1 注解介绍

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

Java 语言中的类、方法、变量、参数和包等都可以被标注。Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。

3.2 内置的注解

Java 定义了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。

1. 作用在代码上的注解

• @Override - 检查该方法是否是重载方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
• @Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
• @SuppressWarnings - 指示编译器去忽略注解中声明的警告。

2. 作用在其他注解的注解(或者说 元注解)

• @Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
• @Documented - 标记这些注解是否包含在用户文档中。
• @Target - 标记这个注解应该是哪种 Java 成员。
• @Inherited - 标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)

####3. 从 Java 7 开始，额外添加了 3 个注解

• @SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
• @FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
• @Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

3.3 Annotation 架构

从中，我们可以看出：

(01) 1 个 Annotation 和 1 个 RetentionPolicy 关联。

可以理解为：每1个Annotation对象，都会有唯一的RetentionPolicy属性。

(02) 1 个 Annotation 和 1~n 个 ElementType 关联。

可以理解为：对于每 1 个 Annotation 对象，可以有若干个 ElementType 属性。

(03) Annotation 有许多实现类，包括：Deprecated, Documented, Inherited, Override 等等。

Annotation 的每一个实现类，都 "和 1 个 RetentionPolicy 关联" 并且 " 和 1~n 个 ElementType 关联"。

下面，我先介绍框架图的左半边(如下图)，即 Annotation, RetentionPolicy, ElementType；然后在就 Annotation 的实现类进行举例说明。

3.4 Annotation组成部分

java Annotation 的组成中，有 3 个非常重要的主干类。它们分别是：

Annotation.java

package java.lang.annotation;
public interface Annotation {
    boolean equals(Object obj);
    int hashCode();
    String toString();
    Class<? extends Annotation> annotationType();
}

####ElementType.java

package java.lang.annotation;
public enum ElementType {
    TYPE,               /* 类、接口（包括注释类型）或枚举声明  */
    FIELD,              /* 字段声明（包括枚举常量）  */
    METHOD,             /* 方法声明  */
    PARAMETER,          /* 参数声明  */
    CONSTRUCTOR,        /* 构造方法声明  */
    LOCAL_VARIABLE,     /* 局部变量声明  */
    ANNOTATION_TYPE,    /* 注释类型声明  */
    PACKAGE             /* 包声明  */
}

RetentionPolicy.java

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了  */
    CLASS,             /* 编译器将Annotation存储于类对应的.class文件中。默认行为  */
    RUNTIME            /* 编译器将Annotation存储于class文件中，并且可由JVM读入 */
}

说明

(01) Annotation 就是个接口。

"每 1 个 Annotation" 都与 "1 个 RetentionPolicy" 关联，并且与 "1～n 个 ElementType" 关联。可以通俗的理解为：每 1 个 Annotation 对象，都会有唯一的 RetentionPolicy 属性；至于 ElementType 属性，则有 1~n 个。

(02) ElementType 是 Enum 枚举类型，它用来指定 Annotation 的类型。

"每 1 个 Annotation" 都与 "1～n 个 ElementType" 关联。当 Annotation 与某个 ElementType 关联时，就意味着：Annotation有了某种用途。例如，若一个 Annotation 对象是 METHOD 类型，则该 Annotation 只能用来修饰方法。

(03) RetentionPolicy 是 Enum 枚举类型，它用来指定 Annotation 的策略。通俗点说，就是不同 RetentionPolicy 类型的 Annotation 的作用域不同。

"每 1 个 Annotation" 都与 "1 个 RetentionPolicy" 关联。

• 1. 若 Annotation 的类型为 SOURCE，则意味着：Annotation 仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了。 例如，" @Override" 标志就是一个 Annotation。当它修饰一个方法的时候，就意味着该方法覆盖父类的方法；并且在编译期间会进行语法检查！编译器处理完后，"@Override" 就没有任何作用了。
• 1. 若 Annotation 的类型为 CLASS，则意味着：编译器将 Annotation 存储于类对应的 .class 文件中，它是 Annotation 的默认行为。
• 1. 若 Annotation 的类型为 RUNTIME，则意味着：编译器将 Annotation 存储于 class 文件中，并且可由JVM读入。

这时，只需要记住"每 1 个 Annotation" 都与 "1 个 RetentionPolicy" 关联，并且与 "1～n 个 ElementType" 关联。学完后面的内容之后，再回头看这些内容，会更容易理解。

3.5 java 自带的 Annotation

理解了上面的 3 个类的作用之后，我们接下来可以讲解 Annotation 实现类的语法定义了。

Annotation 通用定义

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

说明：

上面的作用是定义一个 Annotation，它的名字是 MyAnnotation1。定义了 MyAnnotation1 之后，我们可以在代码中通过 "@MyAnnotation1" 来使用它。 其它的，@Documented, @Target, @Retention, @interface 都是来修饰 MyAnnotation1 的。下面分别说说它们的含义：

(01) @interface

使用 @interface 定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

定义 Annotation 时，@interface 是必须的。

注意：它和我们通常的 implemented 实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他的注解或接口。

(02) @Documented

类和方法的 Annotation 在缺省情况下是不出现在 javadoc 中的。如果使用 @Documented 修饰该 Annotation，则表示它可以出现在 javadoc 中。

定义 Annotation 时，@Documented 可有可无；若没有定义，则 Annotation 不会出现在 javadoc 中。

(03) @Target(ElementType.TYPE)

前面我们说过，ElementType 是 Annotation 的类型属性。而 @Target 的作用，就是来指定 Annotation 的类型属性。

@Target(ElementType.TYPE) 的意思就是指定该 Annotation 的类型是 ElementType.TYPE。这就意味着，MyAnnotation1 是来修饰"类、接口（包括注释类型）或枚举声明"的注解。

定义 Annotation 时，@Target 可有可无。若有 @Target，则该 Annotation 只能用于它所指定的地方；若没有 @Target，则该 Annotation 可以用于任何地方。

(04) @Retention(RetentionPolicy.RUNTIME)

前面我们说过，RetentionPolicy 是 Annotation 的策略属性，而 @Retention 的作用，就是指定 Annotation 的策略属性。

@Retention(RetentionPolicy.RUNTIME) 的意思就是指定该 Annotation 的策略是 RetentionPolicy.RUNTIME。这就意味着，编译器会将该 Annotation 信息保留在 .class 文件中，并且能被虚拟机读取。

定义 Annotation 时，@Retention 可有可无。若没有 @Retention，则默认是 RetentionPolicy.CLASS。

java自带的Annotation

通过上面的示例，我们能理解：@interface 用来声明 Annotation，@Documented 用来表示该 Annotation 是否会出现在 javadoc 中， @Target 用来指定 Annotation 的类型，@Retention 用来指定 Annotation 的策略。

理解这一点之后，我们就很容易理解 java 中自带的 Annotation 的实现类，即 Annotation 架构图的右半边。如下图：

java 常用的 Annotation：

@Deprecated  -- @Deprecated 所标注内容，不再被建议使用。
@Override    -- @Override 只能标注方法，表示该方法覆盖父类中的方法。
@Documented  -- @Documented 所标注内容，可以出现在javadoc中。
@Inherited   -- @Inherited只能被用来标注“Annotation类型”，它所标注的Annotation具有继承性。
@Retention   -- @Retention只能被用来标注“Annotation类型”，而且它被用来指定Annotation的RetentionPolicy属性。
@Target      -- @Target只能被用来标注“Annotation类型”，而且它被用来指定Annotation的ElementType属性。
@SuppressWarnings -- @SuppressWarnings 所标注内容产生的警告，编译器会对这些警告保持静默。

由于 "@Deprecated 和 @Override" 类似，"@Documented, @Inherited, @Retention, @Target" 类似；下面，我们只对 @Deprecated, @Inherited, @SuppressWarnings 这 3 个 Annotation 进行说明。

2.1) @Deprecated

@Deprecated 的定义如下：

@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}

说明：

• (01) @interface -- 它的用来修饰 Deprecated，意味着 Deprecated 实现了 java.lang.annotation.Annotation 接口；即 Deprecated 就是一个注解。 (02) @Documented -- 它的作用是说明该注解能出现在 javadoc 中。
• (03) @Retention(RetentionPolicy.RUNTIME) -- 它的作用是指定 Deprecated 的策略是 RetentionPolicy.RUNTIME。这就意味着，编译器会将Deprecated 的信息保留在 .class 文件中，并且能被虚拟机读取。
• (04) @Deprecated 所标注内容，不再被建议使用。

例如，若某个方法被 @Deprecated 标注，则该方法不再被建议使用。如果有开发人员试图使用或重写被 @Deprecated 标示的方法，编译器会给相应的提示信息。示例如下:

说明：

上面是 eclipse 中的截图，比较类中 "getString1() 和 getString2()" 以及 "testDate() 和 testCalendar()" 。

(01) getString1() 被 @Deprecated 标注，意味着建议不再使用 getString1(); 所以 getString1() 的定义和调用时，都会一横线。这一横线是eclipse() 对 @Deprecated 方法的处理。

getString2() 没有被 @Deprecated 标注，它的显示正常。

(02) testDate() 调用了 Date 的相关方法，而 java 已经建议不再使用 Date 操作日期/时间。因此，在调用 Date的API 时，会产生警告信息，途中的 warnings。

testCalendar() 调用了 Calendar 的 API 来操作日期/时间，java 建议用 Calendar 取代 Date。因此，操作 Calendar 不回产生 warning。

2.2) @Inherited

@Inherited 的定义如下：

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

说明：

• (01) @interface -- 它的用来修饰 Inherited，意味着 Inherited 实现了 java.lang.annotation.Annotation 接口；即 Inherited 就是一个注解。
• (02) @Documented -- 它的作用是说明该注解能出现在 javadoc 中。
• (03) @Retention(RetentionPolicy.RUNTIME) -- 它的作用是指定 Inherited 的策略是 RetentionPolicy.RUNTIME。这就意味着，编译器会将 Inherited 的信息保留在 .class 文件中，并且能被虚拟机读取。
• (04) @Target(ElementType.ANNOTATION_TYPE) -- 它的作用是指定 Inherited 的类型是 ANNOTATION_TYPE。这就意味着，@Inherited 只能被用来标注 "Annotation 类型"。
• (05) @Inherited 的含义是，它所标注的Annotation将具有继承性。

假设，我们定义了某个 Annotaion，它的名称是 MyAnnotation，并且 MyAnnotation 被标注为 @Inherited。现在，某个类 Base 使用了

MyAnnotation，则 Base 具有了"具有了注解 MyAnnotation"；现在，Sub 继承了 Base，由于 MyAnnotation 是 @Inherited的(具有继承性)，所以，Sub 也 "具有了注解 MyAnnotation"。

@Inherited 的使用示例:

InheritableSon.java

import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
 * 自定义的Annotation。
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
    public InheritableFather() {
        // InheritableBase是否具有 Inheritable Annotation
        System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
    }
}
/**
 * InheritableSon 类只是继承于 InheritableFather，
 */
public class InheritableSon extends InheritableFather
{
    public InheritableSon() {
        super();    // 调用父类的构造函数
        // InheritableSon类是否具有 Inheritable Annotation
        System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
    }
    public static void main(String[] args)
    {
        InheritableSon is = new InheritableSon();
    }
}

运行结果：

InheritableFather:true
InheritableSon:true

现在，我们对 InheritableSon.java 进行修改：注释掉 "Inheritable 的 @Inherited 注解"。

InheritableSon.java

import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
/**
 * 自定义的Annotation。
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
//@Inherited
@interface Inheritable
{
}
@Inheritable
class InheritableFather
{
    public InheritableFather() {
        // InheritableBase是否具有 Inheritable Annotation
        System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
    }
}
/**
 * InheritableSon 类只是继承于 InheritableFather，
 */
public class InheritableSon extends InheritableFather
{
    public InheritableSon() {
        super();    // 调用父类的构造函数
        // InheritableSon类是否具有 Inheritable Annotation
        System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
    }
    public static void main(String[] args)
    {
        InheritableSon is = new InheritableSon();
    }
}

运行结果：

InheritableFather:true
InheritableSon:false

对比上面的两个结果，我们发现：当注解 Inheritable 被 @Inherited 标注时，它具有继承性。否则，没有继承性。

2.3) @SuppressWarnings

@SuppressWarnings 的定义如下：

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

说明：

(01) @interface -- 它的用来修饰 SuppressWarnings，意味着 SuppressWarnings 实现了 java.lang.annotation.Annotation 接口；即 SuppressWarnings 就是一个注解。

(02) @Retention(RetentionPolicy.SOURCE) -- 它的作用是指定 SuppressWarnings 的策略是 RetentionPolicy.SOURCE。这就意味着，SuppressWarnings 信息仅存在于编译器处理期间，编译器处理完之后 SuppressWarnings 就没有作用了。

(03) @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) -- 它的作用是指定 SuppressWarnings 的类型同时包括TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE。

• TYPE 意味着，它能标注"类、接口（包括注释类型）或枚举声明"。
• FIELD 意味着，它能标注"字段声明"。
• METHOD 意味着，它能标注"方法"。
• PARAMETER 意味着，它能标注"参数"。
• CONSTRUCTOR 意味着，它能标注"构造方法"。
• LOCAL_VARIABLE 意味着，它能标注"局部变量"。

(04) String[] value(); 意味着，SuppressWarnings 能指定参数

(05) SuppressWarnings 的作用是，让编译器对"它所标注的内容"的某些警告保持静默。例如，"@SuppressWarnings(value={"deprecation", "unchecked"})" 表示对"它所标注的内容"中的 "SuppressWarnings 不再建议使用警告"和"未检查的转换时的警告"保持沉默。示例如下：

说明：

(01) 左边的图中，没有使用 @SuppressWarnings(value={"deprecation"}) , 而 Date 属于 java 不再建议使用的类。因此，调用 Date 的 API 时，会产生警告。而右边的途中，使用了 @SuppressWarnings(value={"deprecation"})。因此，编译器对"调用 Date 的 API 产生的警告"保持沉默。

补充：SuppressWarnings 常用的关键字的表格

deprecation  -- 使用了不赞成使用的类或方法时的警告
unchecked    -- 执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型。
fallthrough  -- 当 Switch 程序块直接通往下一种情况而没有 Break 时的警告。
path         -- 在类路径、源文件路径等中有不存在的路径时的警告。
serial       -- 当在可序列化的类上缺少 serialVersionUID 定义时的警告。
finally      -- 任何 finally 子句不能正常完成时的警告。
all          -- 关于以上所有情况的警告。

3.6 Annotation 的作用

Annotation 是一个辅助类，它在 Junit、Struts、Spring 等工具框架中被广泛使用。

我们在编程中经常会使用到的 Annotation 作用有：

####1）编译检查

Annotation 具有"让编译器进行编译检查的作用"。

例如，@SuppressWarnings, @Deprecated 和 @Override 都具有编译检查作用。

(01) 关于 @SuppressWarnings 和 @Deprecated，已经在"第3部分"中详细介绍过了。这里就不再举例说明了。

(02) 若某个方法被 @Override 的标注，则意味着该方法会覆盖父类中的同名方法。如果有方法被 @Override 标示，但父类中却没有"被 @Override 标注"的同名方法，则编译器会报错。示例如下：

上面是该程序在 eclipse 中的截图。从中，我们可以发现 "getString()" 函数会报错。这是因为 "getString() 被 @Override 所标注，但在OverrideTest 的任何父类中都没有定义 getString1() 函数"。

"将 getString() 上面的 @Override注释掉"，即可解决该错误。

2) 在反射中使用 Annotation

在反射的 Class, Method, Field 等函数中，有许多于 Annotation 相关的接口。

一个简单测试案例：注解 + 反射 实现

/*自定义注解*/
@Documented // 此标注可以生成到JavaDoc中
@Target(ElementType.METHOD)  // 此标注可以定义给方法
@Retention(RetentionPolicy.RUNTIME)  // 此标注可以存储在class字节码文件中，在程序中可以获取
// 此标注的目的，用来标识测试时，被标注的方法是否运行，若有此标注则检测，否则不检测
public @interface Check {
}
/*自定义类*/
public class Calc {
  @Check
  public void add(){
    System.out.println("1+1="+(1+1));
  }
  @Check
  public void subtract(){
    System.out.println("1-1="+(1-1));
  }
  @Check
  public void multi(){
    String str = null;
    str.toString();
    System.out.println("10*10="+(10*10));
  }
  @Check
  public void div(){
    System.out.println("10/0="+(10/0));
  }
  public void show(){
    System.out.println("永无bug");
  }
}
/*测试类*/
public class Test01 {
  public static void main(String[] args) throws IOException {
    Calc calc = new Calc();
    int count = 0;
    // 创建输出流，用来写入异常日志
    BufferedWriter writer = new BufferedWriter(new FileWriter("bug.txt"));
    // 获取字节码对象
    Class cls = calc.getClass();
    // 获取所有的方法
    Method[]methonds = cls.getDeclaredMethods();
    // 循环遍历方法
    for (Method methond : methonds) {
      // 检测方法是否有被@Check标注
      if(methond.isAnnotationPresent(Check.class)){
        // 有，则执行
        try {
          methond.invoke(calc);
        } catch (Exception e) {
          count++;
          writer.write("[第"+count+"次出现异常]");
          writer.newLine();
          writer.write(methond.getName() + "方法出现了异常");
          writer.newLine();
          writer.write("异常的名称" + e.getCause().getClass().getName());
          writer.newLine();
          writer.write("异常的原因" + e.getCause().getMessage());
          writer.newLine();
          writer.write("-------------------------------------");
          writer.newLine();
        }
      }
    }
    writer.write("【本次测试一共出现了"+count+"次异常！】");
    writer.flush();
    writer.close();
  }
}
/*bug.txt文件结果*/
[第1次出现异常]
div方法出现了异常
异常的名称java.lang.ArithmeticException
异常的原因/ by zero
-------------------------------------
[第2次出现异常]
multi方法出现了异常
异常的名称java.lang.NullPointerException
异常的原因null
-------------------------------------
【本次测试一共出现了2次异常！】

3) 根据 Annotation 生成帮助文档

通过给 Annotation 注解加上 @Documented 标签，能使该 Annotation 标签出现在 javadoc 中。

4) 能够帮忙查看查看代码

通过 @Override, @Deprecated 等，我们能很方便的了解程序的大致结构。

另外，我们也可以通过自定义 Annotation 来实现一些功能。