Notes...

annotation Annotation Is a reference data type , After compiling, it is also generated xxx.class file .

@Target(value = {
    ElementType.METHOD,ElementType.CONSTRUCTOR})    	//  Appoint   Where to mark 

@Retention(RetentionPolicy.SOURCE)      							//  Indicates that it will not compile into  class  file 
@Retention(RetentionPolicy.CLASS)       							//  The final compilation is  class  file 
@Retention(RetentionPolicy.RUNTIME)     							//  The final compilation is  class  file ,  And can be read by reflection mechanism 

@Deprecated				//  Annotation is out of date ,  There's a better plan  (  It just plays a role of marking information ,  The marked things can still be used  )

Custom annotation

public @interface MyAnnotation {
    
    /** *  Can be in   The attribute is defined in the annotation  *  It looks like a method ,  It is actually an attribute  * @return */
    String name();
    /** *  color property  */
    String color();
    /** *  Age attribute  */
    int age() default 25;       //  Specify default 
}

//  When using annotations ,  You must assign values to attributes that do not have default values 
@MyAnnotation(name = "xxx",color = "blue")
public class lambdademo {
    
    public static void main(String[] args){
    

    }
}

If there is only one attribute in the annotation , And the attribute is called value Words , When using this annotation , Assign values to properties , You can leave the property name unspecified .
If an attribute in the annotation is an array type , And use this annotation , When assigning values to this attribute , There is only one value in braces , Then braces can be omitted .

public @interface Target {
    
    ElementType[] value();
}

//  When you use it ,  There is only one element in braces ,  Braces can be omitted 
@Target(ElementType.METHOD)		 Equate to 	@Target({
    ElementType.METHOD})

Reflection extraction annotation

precondition

@Retention(RetentionPolicy.RUNTIME)     //  Must be marked  Runtime,  Can be read by the reflection mechanism 
public @interface MyAnnotation {
    
    String name();
    String color();
}

Experimental subjects

@MyAnnotation(name = "on type", color = "red")
public class Cat {
    
    @MyAnnotation(name = "on field", color = "blue")
    private String name;
    private Integer age;
    private Integer sex;
}

Extraction by reflection

    public static void main(String[] args) throws ClassNotFoundException {
    
        Class<?> cls = Class.forName("com.itheima.Cat");

        //  Get the marked on the class  MyAnnotation
        if(cls.isAnnotationPresent(MyAnnotation.class)){
    
            System.out.println("====== Marked on the class ======");
            MyAnnotation ano = cls.getAnnotation(MyAnnotation.class);
            System.out.println(ano);
            String color = ano.color();     //  obtain  color  Property value 
            System.out.println(color);
        }

        //  Get the marked on the attribute  MyAnnotation
        Field[] fields = cls.getDeclaredFields();
        for(Field f : fields){
    
            if(f.isAnnotationPresent(MyAnnotation.class)){
    
                System.out.println("====== Marked on the attribute ======");
                System.out.println(" Marked attributes  " + f.getName());
                System.out.println(f.getAnnotation(MyAnnotation.class));
            }
        }
    }

What's the use of annotations ？
Marking of the program , You can get this mark through reflection .
The program can judge if 【 class / Method / Properties and so on 】 There is this tag information on it , Just do whatever , without , Do what .