Überprüfen Sie jetzt die Java-Anmerkungen
Überblick
Ich entschied mich für Spring Boot für meine Arbeit und musste das Konzept der Annotation in meinen Kopf eingeben, das vor langer Zeit nur den Inhalt des Java-Trainings für neue Absolventen enthielt.
Referenzierte Site
Es war wirklich leicht zu verstehen http://www.atmarkit.co.jp/ait/articles/1105/19/news127.html
Besonders in diesem Beispiel
Anmerkung bedeutet "Kommentar". Ich habe Javadoc-Kommentare verwendet, um Entwicklern zu erklären, wie ein Programm aussieht, aber so möchte ich dem Compiler und der Ausführungsumgebung mitteilen, wie ein Programm aussieht.
Wie Sie dem später in Java beschriebenen konkreten Beispiel entnehmen können, können Sie durch Schreiben von Anmerkungen in das Programm die vom Compiler ausgegebene Warnmeldung unterdrücken und das Verhalten des Programms abhängig von der Ausführungsumgebung ändern.
Für die Verwendung zum Zeitpunkt der Ausführung habe ich hier verwiesen. https://www.qoosky.io/techs/390aad36f8
Versuchen
java version 1.8.0_181 Java(TM) SE Runtime Environment (build 1.8.0_181-b13) Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)
src └test └java └annotation ├ Main.java └ MethodInformation.java
Inhalt
Lassen Sie uns einen Anmerkungstyp nur als Markierung erstellen und festlegen.
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
//Durch Hinzufügen der Zielanmerkung können Sie angeben, an was die Anmerkung angehängt ist.
@Target(ElementType.TYPE)
public @interface MethodInformation {
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
Was ist der Typ von ElementType?
Bitte hier
public enum ElementType { /** Class, interface (including annotation type), or enum declaration */ TYPE, /** Field declaration (includes enum constants) */ FIELD, /** Method declaration */ METHOD, /** Formal parameter declaration */ PARAMETER, /** Constructor declaration */ CONSTRUCTOR, /** Local variable declaration */ LOCAL_VARIABLE, /** Annotation type declaration */ ANNOTATION_TYPE, /** Package declaration */ PACKAGE, /** * Type parameter declaration * * @since 1.8 */ TYPE_PARAMETER, /** * Use of a type * * @since 1.8 */ TYPE_USE }
## Lauf
Es wird problemlos ausgegeben. Da es sich um eine Anmerkung handelt, die nichts Besonderes bewirkt, ändert sich der Ausgabeinhalt nicht.
## Versuchen Sie, eine Anmerkung zu erstellen, die nur an eine Methode angehängt werden kann
#### **`MethodInformation.java`**
```java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.METHOD) //Kann nur an Methoden angehängt werden
public @interface MethodInformation {
}
Es ist eine störende Luft.
Lauf
Wird sicher versagen
Holen Sie sich Anmerkungsinformationen aus der Klasse heraus
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME) //Die Anmerkungsinformationen müssen auch beim Kompilieren → Ausführen beibehalten werden
public @interface MethodInformation {
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
//Ruft den in der Hauptklasse festgelegten Annotationstyp ab
System.out.println(clazz.getAnnotation(MethodInformation.class));
System.out.println("Hello World!");
}
}
Was ist die Art der Aufbewahrungsrichtlinie?
Bitte hier
public enum RetentionPolicy { /** * Annotations are to be discarded by the compiler. */ SOURCE, /** * Annotations are to be recorded in the class file by the compiler * but need not be retained by the VM at run time. This is the default * behavior. */ CLASS, /** * Annotations are to be recorded in the class file by the compiler and * retained by the VM at run time, so they may be read reflectively. * * @see java.lang.reflect.AnnotatedElement */ RUNTIME }
Ausführungsergebnis
Sie können sehen, dass @ test.java.annotation.MethodInformation () ausgegeben wird.
Rufen Sie den Wert der Anmerkung mit dem festgelegten Wert ab
Erstellen Sie ein sogenanntes Annotation-Element und versuchen Sie, seinen Wert zu ermitteln
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInformation {
String testString();
int testInt();
}
Main.java
package test.java.annotation;
@MethodInformation(testString = "this is test", testInt = 12345)
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
MethodInformation methodInformation = (MethodInformation)clazz.getAnnotation(MethodInformation.class);
//Definiert durch eine Methode im Annotationstyp
System.out.println(methodInformation.testString());
System.out.println(methodInformation.testInt());
System.out.println("Hello World!");
}
}
Ausführungsergebnis
Ich konnte den eingestellten Wert sicher sehen
Es ist in Ordnung, sich selbst zu kommentieren
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@MethodInformation(testString = "this is test double", testInt = 1234512345) //Kommentieren Sie sich
public @interface MethodInformation {
String testString() default "test";
int testInt() default 1234;
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
MethodInformation methodInformation = (MethodInformation)clazz.getAnnotation(MethodInformation.class);
System.out.println(methodInformation.testString());
System.out.println(methodInformation.testInt());
System.out.println("Hello World!");
}
}
Ausführungsergebnis
Sie können sehen, dass es nicht überschrieben wurde (es enthält den Standardwert der Anmerkung). Ich fühle mich ein bisschen komisch.
Recommended Posts