Notes and notes

1 notes

Classification of notes

 Single-line comments ： //
 Multiline comment ： /* */
 Documentation Comments ：/** */

effect ： Deliver additional information , Show the programmer , Not involved in compilation

2 notes

Annotation It is a special mark in the code , You can compile 、 Class loading 、 Read while running
, And carry out the corresponding treatment .

2.1 The difference between annotation and annotation

2.2 Custom annotation

package com.yq.day72;

public @interface MyAnno {
    
    // Range of attribute types   Basic data types  string class  Enumeration type   Annotation type 
    //  And arrays of the above types 
    int age();
    double price();
    String name();
    String[] names();
    Class c();
    MyAnno3 anno();
//  Annotations cannot inherit 

}

@interface MyAnno3 {
    

}

Annotations cannot be inherited

2.3 Use of annotations

Instantiate the object not through new, It is Property name = Property value

 Use   When   Assign values to each attribute 
@ Annotation name ( Property name 1=value, Property name 2=value,....)

Be careful ：
1. Each attribute must be assigned
2. There are default values that can be omitted
3. There's only one property , And for value, The assignment can be simplified
4. Copy and use of arrays {}
5. The value of a reference type cannot be null

2.4 Annotation processor

Combine reflection to apply

Specific steps to use

1. Get registered information through reflection 
2. Get file bytecode object 
3. How to get objects , Determine whether the above method uses annotations 
4. An example of getting annotations is used 
5. Get attribute value , To operate 

Method used ： Belong to category Class

boolean isAnnotation()	If so Class Object represents an annotation type, and returns true.
A getAnnotation(Class annotationClass)	If there is a comment of the specified type for the element , Then return these comments , Otherwise return to null.

Code instance ：

package com.yq.day72;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/** * @author [email protected] * @description * @since 2022/07/02 11:41 *  Create a learning object , Don't use new The way , Use reflection and annotation to realize  * name The length of is 5 Between  , Age 18-25 Between  */

// Test class 
public class Demo04 {
    
    // Define a bytecode file object , Assign a value 
    static  Class<?> aClass;
    static {
    
        try {
    
            aClass = Class.forName("com.yq.day72.Student");
        } catch (ClassNotFoundException e) {
    
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException, InstantiationException, IllegalAccessException {
    
        Student zhansa = getInstance("zga", 293);
        System.out.println(zhansa);

    }

    public static Student getInstance(String name,int age) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
    
        // Verification of name   obtain student Properties of name
        Field name1 = aClass.getDeclaredField("name");
        // Decide whether to use annotations   Judgment properties name Whether there are notes on 
        boolean a1 = name1.isAnnotationPresent(NameLimit.class);
        if (a1){
    
            // Get an instance of the annotation 
            NameLimit a2 = name1.getAnnotation(NameLimit.class);
            // Get the attribute value of the annotation 
            int length = a2.length();
            // Judge 
            if (name.length()>length){
    
                throw  new IllegalArgumentException(" The length is large ");
            }
        }

        // Verification of age   obtain age Properties of 
        Field age1 = aClass.getDeclaredField("age");
        // Judge if there is a comment 
        boolean annotationPresent = age1.isAnnotationPresent(AgeLimit.class);
        if (annotationPresent){
    
            // Get an instance of the annotation 
            AgeLimit annotation = age1.getAnnotation(AgeLimit.class);
            // Get attribute value 
            int i = annotation.maxAge();
            int i1 = annotation.minAge();
            if (age>i || age <i1){
    
                throw new IllegalArgumentException(" Age is illegal ！！！！！");
            }
        }

        // Get construction method 
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class);
        // Ignore restrictions 
        declaredConstructor.setAccessible(true);
        // Create student objects 
        Student o = (Student) declaredConstructor.newInstance(name, age);
        return o;
    }
}

class Student{
    
    // annotation 
    @NameLimit
    String name;
    // annotation 
    @AgeLimit
    int age;

    @Override
    public String toString() {
    
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    private Student(String name, int age) {
    
        this.name = name;
        this.age = age;
    }
}


// Yuan notes 
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface NameLimit{
    
    int length() default 5;
}

// Yuan notes 
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface AgeLimit{
    
    int maxAge() default 25;
    int minAge() default 18;
}

2.5 Yuan notes

Notes describing annotations , Metadata meta data
Common meta notes

**@Retention Yuan notes , To define the retention level of our own annotations .**

- RetentionPolicy.RUNTIME
- RetentionPolicy.CLASS   Default 
- RetentionPolicy.SOURCE

**@Target Yuan notes , The purpose of annotation **

 For annotations , Goals that can work ：

1.  The whole class     ElementType.TYPE
2.  Member variables    ElementType.FIELD
3.  Construction method    ElementType.CONSTRUCTOR
4.  Member method    ElementType.METHOD

2.6 annotation VS The configuration file