父類上的注解能被子類繼承嗎，接口上面的注解呢（轉）

原文：

https://www.iteye.com/blog/wzhw2008-1723136

https://www.cnblogs.com/grasp/p/11362118.html

 

我們知道在編寫自定義注解時，可以通過指定@Inherited注解，指明自定義注解是否可以被繼承，接口的處理方式是否一樣。但實現情況又可細分為多種。

子類是否繼承父類的注解：

測試環境如下：

父類的類上和方法上有自定義的注解--MyAnnotation

子類繼承了這個父類，分別：

子類方法，實現了父類上的抽象方法

子類方法，繼承了父類上的方法

子類方法，覆蓋了父類上的方法

測試代碼：

public class TestInherited {

    //    @Inherited  //可以被繼承
    @Retention(java.lang.annotation.RetentionPolicy.RUNTIME)   //可以通過反射讀取注解
    public @interface MyAnnotation {
        String value();
    }

    @MyAnnotation(value = "類名上的注解")
    public abstract class ParentClass {

        @MyAnnotation(value = "父類的abstractMethod方法")
        public abstract void abstractMethod();

        @MyAnnotation(value = "父類的doExtends方法")
        public void doExtends() {
            System.out.println(" ParentClass doExtends ...");
        }

        @MyAnnotation(value = "父類的doHandle方法")
        public void doHandle() {
            System.out.println(" ParentClass doHandle ...");
        }
    }

    public class SubClass extends ParentClass {

        //子類實現父類的抽象方法
        @Override
        public void abstractMethod() {
            System.out.println("子類實現父類的abstractMethod抽象方法");
        }

        //子類繼承父類的doExtends方法

        //子類覆蓋父類的doHandle方法
        @Override
        public void doHandle() {
            System.out.println("子類覆蓋父類的doHandle方法");
        }
    }

    public static void main(String[] args) throws SecurityException, NoSuchMethodException {

        Class<SubClass> clazz = SubClass.class;

        if (clazz.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation cla = clazz.getAnnotation(MyAnnotation.class);
            System.out.println("子類繼承到父類類上Annotation,其信息如下：" + cla.value());
        } else {
            System.out.println("子類沒有繼承到父類類上Annotation");
        }

        // 實現抽象方法測試
        Method method = clazz.getMethod("abstractMethod", new Class[]{});
        if (method.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation ma = method.getAnnotation(MyAnnotation.class);
            System.out.println("子類實現父類的abstractMethod抽象方法，繼承到父類抽象方法中的Annotation,其信息如下：" + ma.value());
        } else {
            System.out.println("子類實現父類的abstractMethod抽象方法，沒有繼承到父類抽象方法中的Annotation");
        }

        //繼承測試
        Method methodOverride = clazz.getMethod("doExtends", new Class[]{});
        if (methodOverride.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation ma = methodOverride.getAnnotation(MyAnnotation.class);
            System.out.println("子類繼承父類的doExtends方法，繼承到父類doExtends方法中的Annotation,其信息如下：" + ma.value());
        } else {
            System.out.println("子類繼承父類的doExtends方法，沒有繼承到父類doExtends方法中的Annotation");
        }

        //覆蓋測試
        Method method3 = clazz.getMethod("doHandle", new Class[]{});
        if (method3.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation ma = method3.getAnnotation(MyAnnotation.class);
            System.out.println("子類覆蓋父類的doHandle方法，繼承到父類doHandle方法中的Annotation,其信息如下：" + ma.value());
        } else {
            System.out.println("子類覆蓋父類的doHandle方法，沒有繼承到父類doHandle方法中的Annotation");
        }
    }
}

編寫自定義注解時未寫@Inherited的運行結果

子類沒有繼承到父類類上Annotation
子類實現父類的abstractMethod抽象方法，沒有繼承到父類抽象方法中的Annotation
子類繼承父類的doExtends方法，繼承到父類doExtends方法中的Annotation,其信息如下：父類的doExtends方法
子類覆蓋父類的doHandle方法，沒有繼承到父類doHandle方法中的Annotation

編寫自定義注解時寫了@Inherited的運行結果

子類繼承到父類類上Annotation,其信息如下：類名上的注解
子類實現父類的abstractMethod抽象方法，沒有繼承到父類抽象方法中的Annotation
子類繼承父類的doExtends方法，繼承到父類doExtends方法中的Annotation,其信息如下：父類的doExtends方法
子類覆蓋父類的doHandle方法，沒有繼承到父類doHandle方法中的Annotation

結論

-----------------------------------------------------------------

父類的類上和方法上有自定義的注解，

子類繼承了這個父類，的情況下。

	編寫自定義注解時未寫@Inherited的運行結果：	編寫自定義注解時寫了@Inherited的運行結果：
子類的類上能否繼承到父類的類上的注解？	否	能
子類方法，實現了父類上的抽象方法，這個方法能否繼承到注解？	否	否
子類方法，繼承了父類上的方法，這個方法能否繼承到注解？	能	能
子類方法，覆蓋了父類上的方法，這個方法能否繼承到注解？	否	否

 

  

我們知道在編寫自定義注解時，可以通過指定@Inherited注解，指明自定義注解是否可以被繼承。

通過測試結果來看，@Inherited 只是可控制 對類名上注解是否可以被繼承。不能控制方法上的注解是否可以被繼承。

 

類自動繼承其接口的注解

public class TestInheritedInf {

    //@Inherited  //可以被繼承
    @Retention(java.lang.annotation.RetentionPolicy.RUNTIME)   //可以通過反射讀取注解
    public @interface MyAnnotation {
        String value();
    }

    @MyAnnotation(value = "接口上的注解")
    public interface ParentInf {

        @MyAnnotation(value = "接口的abstractMethod方法")
        void abstractMethod();
    }

    public class SubImpl implements ParentInf {

        //子類實現父類的抽象方法
        @Override
        public void abstractMethod() {
            System.out.println("子類實現接口的abstractMethod抽象方法");
        }
    }

    public static void main(String[] args) throws Exception {

        Class<SubImpl> clazz = SubImpl.class;
        
        Class[] i = clazz.getInterfaces();
        for (Class clz : i) {
            if(clz.isAnnotationPresent(MyAnnotation.class)){
                MyAnnotation w = (MyAnnotation)clz.getAnnotation(MyAnnotation.class);
                System.out.println("value:" + w.value());
            }

            Method[] methods = clz.getMethods();
            for (Method method : methods) {
                if (method.isAnnotationPresent(MyAnnotation.class)) {
                    MyAnnotation w = method.getAnnotation(MyAnnotation.class);
                    System.out.println("value:" + w.value());
                }
            }
        }
    }
}

編寫自定義注解時未寫@Inherited的運行結果

value:接口上的注解
value:接口的abstractMethod方法

編寫自定義注解時寫了@Inherited的運行結果

value:接口上的注解
value:接口的abstractMethod方法

結論：實現類不管加不加@Inherited都能讀取到定義接口的接口或者方法上面的注解

 

順便說下

如果實現的多個接口聲明了同樣的方法，實現類只要實現一次就可以了，然后每個接口都能調用。

在spring中比如GetMapping等注解，不僅可以實現接口讀取，也可以被繼承讀取，因為通過spring框架通過反射和代理處理了的