Notes learning summary

1. annotation

1.1 What is annotation

Annotation yes JDK1.5 New technology introduced after

1.2 The role of annotations

Not the program itself , The procedure can be explained ( This point is consistent with the notes (comment) No difference )

It can be read by other programs （ Such as compiler ）

2. Built-in annotations

2.1Override

It's defined in java.lang.Override in , This note applies only to rhetorical devices , Indicates that a method intends to override another method declaration in the superclass

2.2Deprecated

When a type or type member uses @Deprecated Embellished words , The compiler will not encourage the use of this tagged program element .

2.3SuppressWarnings

Used to suppress compile time warnings

package com.lixi;

// The following three annotations are built-in annotations 
// Suppression warning , It is not recommended to use more 
@SuppressWarnings("all")
public class Test01 {
    // Rewritten notes 
    @Override
    public String toString() {
        return super.toString();
    }

    // Programmers are not recommended to use ,
    @Deprecated
    public void test() {
        System.out.println("Deprecated");
    }

    public static void main(String[] args) {
        Test01 t = new Test01();
        t.test();
    }
}

3. Yuan notes

The role of meta annotation is to annotate other annotations

3.1 Target

Simply put, it means where the described annotation can be used

  ● ElementType.CONSTRUCTOR: Used to describe a constructor
  ● ElementType.FIELD: Member variables 、 object 、 attribute （ Include enum example ）
  ● ElementType.LOCAL_VARIABLE: Used to describe local variables
  ● ElementType.METHOD: Used to describe a method
  ● ElementType.PACKAGE: Used to describe a package
  ● ElementType.PARAMETER: Used to describe parameters
  ● ElementType.TYPE: Used to describe a class 、 Interface ( Including annotation types ) or enum Statement

3.2Retention

Used to describe the life cycle of annotations

   ●  RetentionPolicy.SOURCE : Discard... At compile time . These annotations don't make any sense after compilation , So they don't write bytecode [email protected], @SuppressWarnings All belong to this kind of annotation .
  ●   RetentionPolicy.CLASS : Discard... When the class is loaded . Useful in bytecode file processing . Annotations default to this way
  ●   RetentionPolicy.RUNTIME : Never throw away , The runtime also keeps the comment , So you can use the reflection mechanism to read the annotation information . Our custom annotations usually use this way .

3.3Documented

A simple Annotations Mark notes , Indicates whether to add annotation information to java In the document .

3.4Inherited

Subclasses can inherit comments from their parents

package com.lixi;

import java.lang.annotation.*;

@SuppressWarnings("all")
@MyAnnotation
public class Test02 {
    // Test meta annotation , Focus on mastering Target,Retention
    @MyAnnotation
    public void Demo() {
    }
}

// Define an annotation 
// Target  It indicates where our custom annotations can be used 
@Target(value = {ElementType.METHOD, ElementType.TYPE})
// Retention  It indicates when our annotations are still valid ,RUNTIME > CLASS > SOURCE
@Retention(value = RetentionPolicy.RUNTIME)
// Documented  Indicates whether to generate our annotation in JAVAdoc in 
@Documented
// Inherited  Subclasses can inherit comments from their parents 
@Inherited
@interface MyAnnotation {

}

4. Custom annotation

Be careful

1.Annotation Type is defined as @interface, be-all Annotation Will automatically inherit java.lang.Annotation This interface , And you can't inherit other classes or interfaces .

2. Parameter members can only use public Or default (default) These two access modifications .

3. The name of the method is the name of the parameter

4. The return type is the parameter type （ The return type can only be a basic type String,enum,Class）

5. Can pass default To declare the default value of the parameter

6. If there is only one parameter member , We generally default to value

package com.lixi;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@SuppressWarnings("all")
public class Test03 {
    @Annotation2(schools = {" university "},id=-1)
    public void Demo(){
    }
    @Annotation3("jili")
    public void Demo1(){
    }
}
@SuppressWarnings("all")
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Annotation2 {
// Annotated parameters ：   Parameter type  +   Parameter name   +  （）
    //default Indicates the default value of the annotation , With default values , You don't have to assign values to annotations 
     String value() default "jili";
     int count () default 0;
     int id () ;
     String[] schools() ;
}
@SuppressWarnings("all")
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Annotation3 {
    // A single parameter uses value, You don't have to write value
    String value();
}

General annotations do not have so many parameters , It's just a demonstration