父類上的註解能被子類繼承嗎

父類上的註解能被子類繼承嗎html

咱們知道在編寫自定義註解時，能夠經過指定@Inherited註解，指明自定義註解是否能夠被繼承。但實現狀況又可細分爲多種。java

測試環境以下

父類的類上和方法上有自定義的註解--MyAnnotationide

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

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

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

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

MyAnnotation自定義註解

自定義註解

package  test.annotation;  
import  java.lang.annotation.Inherited;  
import  java.lang.annotation.Retention;  
/**  
 * 自定義註解  
 */   
//@Inherited  //能夠被繼承   
@Retention (java.lang.annotation.RetentionPolicy.RUNTIME)   //能夠經過反射讀取註解   
public   @interface  MyAnnotation {    
    String value();    
}

父類

package  test.annotation;  
@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 ..." );  
    }  
}

子類

package  test.annotation;  
public   class  SubClass  extends  ParentClass{    
    
    //子類實現父類的抽象方法   
    @Override     
    public   void  abstractMethod() {    
        System.out.println("子類實現父類的abstractMethod抽象方法" );    
    }    
      
    //子類繼承父類的doExtends方法   
      
    //子類覆蓋父類的doHandle方法   
    @Override     
    public   void  doHandle(){  
        System.out.println("子類覆蓋父類的doHandle方法" );   
    }  
}

測試類

package  test.annotation;  
  
import  java.lang.reflect.Method;  
  
public   class  MainTest {  
    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的運行結果

子類沒有繼承到父類類上Annotationblog

子類實現父類的abstractMethod抽象方法，沒有繼承到父類抽象方法中的Annotation繼承

子類繼承父類的doExtends方法，繼承到父類doExtends方法中的Annotation,其信息以下：父類的doExtends方法事務

子類覆蓋父類的doHandle方法，沒有繼承到父類doHandle方法中的Annotation

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

子類繼承到父類類上Annotation,其信息以下：類名上的註解

子類實現父類的abstractMethod抽象方法，沒有繼承到父類抽象方法中的Annotation

子類繼承父類的doExtends方法，繼承到父類doExtends方法中的Annotation,其信息以下：父類的doExtends方法

子類覆蓋父類的doHandle方法，沒有繼承到父類doHandle方法中的Annotation

結論

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

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

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

咱們知道在編寫自定義註解時，能夠經過指定@Inherited註解，指明自定義註解是否能夠被繼承。

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

附註 Transactional

Spring 實現事務的註解@Transactional 是能夠被繼承的，

經過查看它的源碼能夠看到@Inherited。