package com.anno;
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
@Retention(RetentionPolicy.RUNTIME) 
public @interface MyAnno {
	//當(dāng)注解中使用的屬性名為value時，對其賦值時可以不指定屬性的名稱而直接寫上屬性值接口；
	//除了value意外的變量名都需要使用name=value的方式賦值。
	String value() default "ddd";  //取的注解中的值 @MyAnno(value ="sss")默認值
	String name() default "silence";
}
 

package anno;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
@MyAnnotation("sss")
public class AnnotationTest {
	public void COUT(){
		System.out.println("COUT");
	}
	public static void main(String[] args) throws Exception{
		//1、讀取注解
		Annotation[] annotations = AnnotationTest.class.getAnnotations();
		System.out.println(((MyAnnotation)annotations[0]).value());
                 System.out.println(((MyAnnotation)annotations[0]).name());
		//2、判斷使用注解的元素
		Class c = AnnotationTest.class;
		c.isAnnotationPresent(MyAnnotation.class);
		System.out.println(c.isAnnotationPresent(MyAnnotation.class));
		//3、元素注解
		AnnotatedElement  element = MyAnnotation.class;
		element.getAnnotation(MyAnnotation.class);
	}
}

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

@Documented
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Yts {
    public enum YtsType{util,entity,service,model};
   public YtsType classType() default YtsType.util;
}

@Documented
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 @Inherited
 public @interface HelloWorld {
    public String name()default "";
 }

public class ParseAnnotation {
      public void parseMethod(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException{
   Object obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});
     for(Method method : clazz.getDeclaredMethods()){
         HelloWorld say = method.getAnnotation(HelloWorld.class);
         String name = "";
         if(say != null){
            name = say.name();
            method.invoke(obj, name);
         }
        Yts yts = (Yts)method.getAnnotation(Yts.class);
        if(yts != null){
           if(YtsType.util.equals(yts.classType())){
           System.out.println("this is a util method");
         }else{
             System.out.println("this is a other method");
             }
         }
       }
     }
     @SuppressWarnings("unchecked")
     public void parseType(Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
         Yts yts = (Yts) clazz.getAnnotation(Yts.class);
         if(yts != null){
             if(YtsType.util.equals(yts.classType())){
                 System.out.println("this is a util class");
             }else{
                 System.out.println("this is a other class");
             }
         }
     }
 }

@Yts(classType =YtsType.util)
 public class SayHell {
     @HelloWorld(name = " 小明 ")
     @Yts
     public void sayHello(String name){
         if(name == null || name.equals("")){
             System.out.println("hello world!");
         }else{
             System.out.println(name + "say hello world!");
         }
     }
 }

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException, InstantiationException {
         ParseAnnotation parse = new ParseAnnotation();
         parse.parseMethod(SayHell.class);
         parse.parseType(SayHell.class);
     }

class A {
    private String id;
    A(String id){
        this.id = id;
    }
    @Override
    public String toString() {
        return id;
    }
}

class A {
    private String id;
    A(String id){
        this.id = id;
    }
    @Deprecated
    public void execute(){
        System.out.println(id);
    }
    public static void main(String[] args) {
        A a = new A("a123");
        a.execute();
    }
}

@SuppressWarnings("unchecked")
public static void main(String[] args) {
    List list = new ArrayList();
    list.add("abc");
}

public @interface MyAnnotation {
}

public class AnnotationTest2 {
    @MyAnnotation
    public void execute(){
        System.out.println("method");
    }
}

public @interface MyAnnotation {
    String value1();
}

public class AnnotationTest2 {
    @MyAnnotation(value1="abc")
    public void execute(){
        System.out.println("method");
    }
}

public @interface MyAnnotation {
    String value1() default "abc";
}

public @interface MyAnnotation {
    String value1() default "abc";
    MyEnum value2() default MyEnum.Sunny;
}
enum MyEnum{
    Sunny,Rainy
}

public class AnnotationTest2 {
    @MyAnnotation(value1="a", value2=MyEnum.Sunny)
    public void execute(){
        System.out.println("method");
    }
}

public @interface MyAnnotation {
    String[] value1() default "abc";
}

public class AnnotationTest2 {
    @MyAnnotation(value1={"a","b"})
    public void execute(){
        System.out.println("method");
    }
}

@Retention(RetentionPolicy.CLASS)
public @interface MyAnnotation {
    String[] value1() default "abc";
}

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String[] value1() default "abc";
}

public class AnnotationTest2 {
    @MyAnnotation(value1={"a","b"})
    @Deprecated
    public void execute(){
        System.out.println("method");
    }
}

public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
    AnnotationTest2 annotationTest2 = new AnnotationTest2();
    //獲取AnnotationTest2的Class實例
    Class<AnnotationTest2> c = AnnotationTest2.class;
    //獲取需要處理的方法Method實例
    Method method = c.getMethod("execute", new Class[]{});
    //判斷該方法是否包含MyAnnotation注解
    if(method.isAnnotationPresent(MyAnnotation.class)){
        //獲取該方法的MyAnnotation注解實例
        MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
        //執(zhí)行該方法
        method.invoke(annotationTest2, new Object[]{});
        //獲取myAnnotation
        String[] value1 = myAnnotation.value1();
        System.out.println(value1[0]);
    }
    //獲取方法上的所有注解
    Annotation[] annotations = method.getAnnotations();
    for(Annotation annotation : annotations){
        System.out.println(annotation);
    }
}

@Target(ElementType.ANNOTATION_TYPE)
    public @interface MetaAnnotationType {
        ...
    }

@Target({}) 
    public @interface MemberType {
        ...
    }

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})
    public @interface Bogus {
        ...
    }

public enum ElementType
extends Enum<ElementType>

@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String[] value1() default "abc";
}

@Documented
public @interface MyAnnotation {
    String[] value1() default "abc";
}

public class AnnotationTest2 {
    @MyAnnotation(value1={"a","b"})
    public void execute(){
        System.out.println("method");
    }
}

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)
public @interface Inherited