Annotation之二：@Inherited注解继承情况
@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。
子类中能否继承注解如下：（类和接口情况）
上面的结果同样适用子类的子类。
示例1：自定义注解标记在类上的继承情况
1、自定义注解
package com.dxz.annotation.demo; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; @Inherited // 可以被继承 @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) // 可以通过反射读取注解 public @interface BatchExec { String value(); }
2、被注解的父类
package com.dxz.annotation.demo; @BatchExec(value = "类名上的注解") public abstract class ParentClass { @BatchExec(value = "父类的abstractMethod方法") public abstract void abstractMethod(); @BatchExec(value = "父类的doExtends方法") public void doExtends() { System.out.println(" ParentClass doExtends ..."); } @BatchExec(value = "父类的doHandle方法") public void doHandle() { System.out.println(" ParentClass doHandle ..."); } //@BatchExec(value = "父类的doHandle方法") public void doHandle2() { System.out.println(" ParentClass doHandle ..."); } }
子类：
package com.dxz.annotation.demo; public class SubClass1 extends ParentClass { // 子类实现父类的抽象方法 @Override public void abstractMethod() { System.out.println("子类实现父类的abstractMethod抽象方法"); } //子类继承父类的doExtends方法 // 子类覆盖父类的doHandle方法 @Override public void doHandle() { System.out.println("子类覆盖父类的doHandle方法"); } }
测试类：
package com.dxz.annotation.demo; import java.lang.reflect.Method; public class MainTest1 { public static void main(String[] args) throws SecurityException, NoSuchMethodException { Class<SubClass1> clazz = SubClass1.class; if (clazz.isAnnotationPresent(BatchExec.class)) { BatchExec cla = clazz.getAnnotation(BatchExec.class); System.out.println("类：子类可继承，注解读取='" + cla.value() + "'"); } else { System.out.println("类：子类不能继承到父类类上Annotation"); } // 实现抽象方法测试 Method method = clazz.getMethod("abstractMethod", new Class[] {}); if (method.isAnnotationPresent(BatchExec.class)) { BatchExec ma = method.getAnnotation(BatchExec.class); System.out.println("子类实现抽象方法：子类可继承，注解读取='" + ma.value() + "'"); } else { System.out.println("子类实现抽象方法：没有继承到父类抽象方法中的Annotation"); } // 子类未重写的方法 Method methodOverride = clazz.getMethod("doExtends", new Class[] {}); if (methodOverride.isAnnotationPresent(BatchExec.class)) { BatchExec ma = methodOverride.getAnnotation(BatchExec.class); System.out.println("子类未实现方法：子类可继承，注解读取='" + ma.value() + "'"); } else { System.out.println("子类未实现方法：没有继承到父类doExtends方法中的Annotation"); } // 子类重写的方法 Method method3 = clazz.getMethod("doHandle", new Class[] {}); if (method3.isAnnotationPresent(BatchExec.class)) { BatchExec ma = method3.getAnnotation(BatchExec.class); System.out.println("子类覆盖父类的方法：继承到父类doHandle方法中的Annotation,其信息如下：" + ma.value()); } else { System.out.println("子类覆盖父类的方法:没有继承到父类doHandle方法中的Annotation"); } // 子类重写的方法 Method method4 = clazz.getMethod("doHandle2", new Class[] {}); if (method4.isAnnotationPresent(BatchExec.class)) { BatchExec ma = method4.getAnnotation(BatchExec.class); System.out.println("子类未实现方法doHandle2：子类可继承，注解读取='" + ma.value()); } else { System.out.println("子类未实现方法doHandle2：没有继承到父类doHandle2方法中的Annotation"); } } }
结果：
类：子类可继承，注解读取='类名上的注解'--场景2 子类实现抽象方法：没有继承到父类抽象方法中的Annotation--场景4 子类未实现方法：子类可继承，注解读取='父类的doExtends方法'--场景6 子类覆盖父类的方法:没有继承到父类doHandle方法中的Annotation--场景8 子类未实现方法doHandle2：没有继承到父类doHandle2方法中的Annotation--场景5
示例2：自定义注解标记在接口上的继承情况
package com.dxz.annotation.demo3; @BatchExec(value = "接口上的注解") public interface Parent { void abstractMethod(); }
接口的继承类
package com.dxz.annotation.demo3; import com.dxz.annotation.BatchExec; ///@BatchExec(value = "类名上的注解") public abstract class ParentClass3 { public void abstractMethod() { System.out.println("ParentClass3"); } @BatchExec(value = "父类中新增的doExtends方法") public void doExtends() { System.out.println(" ParentClass doExtends ..."); } }
该继承类的注解可见测试：
package com.dxz.annotation.demo3; import java.lang.reflect.Method; import com.dxz.annotation.BatchExec; public class MainTest3 { public static void main(String[] args) throws SecurityException, NoSuchMethodException { Class<ParentClass3> clazz = ParentClass3.class; if (clazz.isAnnotationPresent(BatchExec.class)) { BatchExec cla = clazz.getAnnotation(BatchExec.class); System.out.println("类：子类可继承，注解读取='" + cla.value()+"'"); } else { System.out.println("类：子类不能继承到接口类上Annotation"); } // 实现抽象方法测试 Method method = clazz.getMethod("abstractMethod", new Class[] {}); if (method.isAnnotationPresent(BatchExec.class)) { BatchExec ma = method.getAnnotation(BatchExec.class); System.out.println("子类实现抽象方法：子类可继承，注解读取='" + ma.value()+"'"); } else { System.out.println("子类实现抽象方法：没有继承到接口抽象方法中的Annotation"); } //子类中新增方法 Method methodOverride = clazz.getMethod("doExtends", new Class[] {}); if (methodOverride.isAnnotationPresent(BatchExec.class)) { BatchExec ma = methodOverride.getAnnotation(BatchExec.class); System.out.println("子类中新增方法：注解读取='" + ma.value()+"'"); } else { System.out.println("子类中新增方法：不能读取注解"); } } }
结果：
类：子类不能继承到接口类上Annotation--场景12
子类实现抽象方法：没有继承到接口抽象方法中的Annotation--场景14
子类中新增方法：注解读取='父类中新增的doExtends方法'--场景16
子类的子类注解继承情况：
package com.dxz.annotation.demo3; public class SubClass3 extends ParentClass3 { // 子类实现父类的抽象方法 @Override public void abstractMethod() { System.out.println("子类实现父类的abstractMethod抽象方法"); } // 子类覆盖父类的doExtends方法 }
测试类：
package com.dxz.annotation.demo3; import java.lang.reflect.Method; import com.dxz.annotation.BatchExec; public class MainTest33 { public static void main(String[] args) throws SecurityException, NoSuchMethodException { Class<SubClass3> clazz = SubClass3.class; if (clazz.isAnnotationPresent(BatchExec.class)) { BatchExec cla = clazz.getAnnotation(BatchExec.class); System.out.println("类：子类可继承，注解读取='" + cla.value()+"'"); } else { System.out.println("类：子类不能继承到父类类上Annotation"); } // 实现抽象方法测试 Method method = clazz.getMethod("abstractMethod", new Class[] {}); if (method.isAnnotationPresent(BatchExec.class)) { BatchExec ma = method.getAnnotation(BatchExec.class); System.out.println("子类实现抽象方法：子类可继承，注解读取='" + ma.value()+"'"); } else { System.out.println("子类实现抽象方法：没有继承到父类抽象方法中的Annotation"); } //子类未重写的方法 Method methodOverride = clazz.getMethod("doExtends", new Class[] {}); if (methodOverride.isAnnotationPresent(BatchExec.class)) { BatchExec ma = methodOverride.getAnnotation(BatchExec.class); System.out.println("子类未实现方法：子类可继承，注解读取='" + ma.value()+"'"); } else { System.out.println("子类未实现方法：没有继承到父类doExtends方法中的Annotation"); } } }
结果：
类：子类不能继承到父类类上Annotation
子类实现抽象方法：没有继承到父类抽象方法中的Annotation--场景14
子类未实现方法：子类可继承，注解读取='父类中新增的doExtends方法'--场景18
附注
-----------------------------------------------------------------
Spring 实现事务的注解@Transactional 是可以被继承的，
通过查看它的源码可以看到@Inherited。
