Java-Anmerkungstypen
Java-Anmerkungstypen
In diesem Tutorial lernen wir anhand von Beispielen verschiedene Arten von Java-Annotationen kennen.
Java-Annotationen sind Metadaten (Daten über Daten) für unseren Programmquellcode. Es gibt mehrere vordefinierte Anmerkungen, die von Java SE bereitgestellt werden. Darüber hinaus können wir auch benutzerdefinierte Anmerkungen nach unseren Bedürfnissen erstellen.
Wenn Sie nicht wissen, was Anmerkungen sind, besuchen Sie das Java-Annotations-Tutorial.
Diese Anmerkungen können wie folgt kategorisiert werden:
1. Vordefinierte Anmerkungen
@Deprecated@Override@SuppressWarnings@SafeVarargs@FunctionalInterface
2. Benutzerdefinierte Anmerkungen
3. Meta-Anmerkungen
@Retention@Documented@Target@Inherited@Repeatable
Vordefinierte Anmerkungstypen
1. @Veraltet
Die @Deprecated annotation ist eine Markierungsannotation, die angibt, dass das Element (Klasse, Methode, Feld usw.) veraltet ist und durch ein neueres Element ersetzt wurde.
Seine Syntax ist:
@Deprecated
accessModifier returnType deprecatedMethodName() { ... }
Wenn ein Programm das als veraltet deklarierte Element verwendet, generiert der Compiler eine Warnung.
Wir verwenden Javadoc @deprecated -Tag zum Dokumentieren des veralteten Elements.
/**
* @deprecated
* why it was deprecated
*/
@Deprecated
accessModifier returnType deprecatedMethodName() { ... }
Beispiel 1:@Veraltetes Anmerkungsbeispiel
class Main {
/**
* @deprecated
* This method is deprecated and has been replaced by newMethod()
*/
@Deprecated
public static void deprecatedMethod() {
System.out.println("Deprecated method");
}
public static void main(String args[]) {
deprecatedMethod();
}
}
Ausgabe
Deprecated method
2. @Override
Die @Override Die Anmerkung gibt an, dass eine Methode einer Unterklasse die Methode der Oberklasse mit demselben Methodennamen, Rückgabetyp und derselben Parameterliste überschreibt.
Es ist nicht zwingend erforderlich, @Override zu verwenden beim Überschreiben einer Methode. Wenn wir es jedoch verwenden, gibt der Compiler einen Fehler aus, wenn etwas falsch ist (z. B. falscher Parametertyp), während er die Methode überschreibt.
Beispiel 2:Beispiel für eine @Override-Anmerkung
class Animal {
// overridden method
public void display(){
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// overriding method
@Override
public void display(){
System.out.println("I am a dog");
}
public void printMessage(){
display();
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printMessage();
}
}
Ausgabe
I am a dog
In diesem Beispiel durch Erstellen eines Objekts dog1 von Hund Klasse, können wir ihre Methode printMessage() aufrufen der dann display() ausführt Aussage.
Seit display() In beiden Klassen ist die Methode der Unterklasse Dog definiert überschreibt die Methode der Oberklasse Animal . Daher der display() der Unterklasse aufgerufen wird.
3. @SuppressWarnings
Wie der Name schon sagt, der @SuppressWarnings Annotation weist den Compiler an, Warnungen zu unterdrücken, die während der Programmausführung generiert werden.
Wir können die Art der zu unterdrückenden Warnungen angeben. Die Warnungen, die unterdrückt werden können, sind Compiler-spezifisch, aber es gibt zwei Kategorien von Warnungen:veraltet und deaktiviert .
Um eine bestimmte Kategorie von Warnungen zu unterdrücken, verwenden wir:
@SuppressWarnings("warningCategory")
Zum Beispiel
@SuppressWarnings("deprecated")
Um mehrere Kategorien von Warnungen zu unterdrücken, verwenden wir:
@SuppressWarnings({"warningCategory1", "warningCategory2"})
Zum Beispiel
@SuppressWarnings({"deprecated", "unchecked"})
Kategorie deprecated weist den Compiler an, Warnungen zu unterdrücken, wenn wir ein veraltetes Element verwenden.
Kategorie unchecked weist den Compiler an, Warnungen zu unterdrücken, wenn wir Rohtypen verwenden.
Und undefinierte Warnungen werden ignoriert. Zum Beispiel
@SuppressWarnings("someundefinedwarning")
Beispiel 3:Beispiel für eine @SuppressWarnings-Anmerkung
class Main {
@Deprecated
public static void deprecatedMethod() {
System.out.println("Deprecated method");
}
@SuppressWarnings("deprecated")
public static void main(String args[]) {
Main depObj = new Main();
depObj. deprecatedMethod();
}
}
Ausgabe
Deprecated method
Hier, deprecatedMethod() wurde als veraltet markiert und gibt bei Verwendung Compiler-Warnungen aus. Durch die Verwendung des @SuppressWarnings("deprecated") Annotation können wir Compiler-Warnungen vermeiden.
4. @SafeVarargs
Der @SafeVarargs Annotation bestätigt, dass die annotierte Methode oder der Konstruktor keine unsicheren Operationen an seinen Varargs (variable Anzahl von Argumenten) durchführt.
Wir können diese Annotation nur für Methoden oder Konstruktoren verwenden, die nicht überschrieben werden können. Dies liegt daran, dass die Methoden, die sie überschreiben, möglicherweise unsichere Vorgänge ausführen.
Vor Java 9 konnten wir diese Annotation nur für finale oder statische Methoden verwenden, da sie nicht überschrieben werden können. Wir können diese Anmerkung jetzt auch für private Methoden verwenden.
Beispiel 4:@SafeVarargs-Anmerkungsbeispiel
import java.util.*;
class Main {
private void displayList(List<String>... lists) {
for (List<String> list : lists) {
System.out.println(list);
}
}
public static void main(String args[]) {
Main obj = new Main();
List<String> universityList = Arrays.asList("Tribhuvan University", "Kathmandu University");
obj.displayList(universityList);
List<String> programmingLanguages = Arrays.asList("Java", "C");
obj.displayList(universityList, programmingLanguages);
}
}
Warnungen
Type safety: Potential heap pollution via varargs parameter lists Type safety: A generic array of List<String> is created for a varargs parameter
Ausgabe
Note: Main.java uses unchecked or unsafe operations. [Tribhuvan University, Kathmandu University] [Tribhuvan University, Kathmandu University] [Java, C]
Hier, List ... lists gibt ein Argument variabler Länge vom Typ List an . Das bedeutet, dass die Methode displayList() kann null oder mehr Argumente haben.
Das obige Programm wird ohne Fehler kompiliert, gibt aber Warnungen aus, wenn @SafeVarargs Anmerkung wird nicht verwendet.
Wenn wir @SafeVarargs verwenden Anmerkung im obigen Beispiel,
@SafeVarargs
private void displayList(List<String>... lists) { ... }
Wir erhalten die gleiche Ausgabe, aber ohne Warnungen. Ungeprüfte Warnungen werden ebenfalls unterdrückt, wenn wir diese Anmerkung verwenden.
5. @FunctionalInterface
Java 8 hat diesen @FunctionalInterface erstmals eingeführt Anmerkung. Diese Anmerkung gibt an, dass die Typdeklaration, für die sie verwendet wird, eine funktionale Schnittstelle ist. Eine funktionale Schnittstelle kann nur eine abstrakte Methode haben.
Beispiel 5:@FunctionalInterface-Anmerkungsbeispiel
@FunctionalInterface
public interface MyFuncInterface{
public void firstMethod(); // this is an abstract method
}
Nehmen wir an, wir fügen eine weitere abstrakte Methode hinzu
@FunctionalInterface
public interface MyFuncInterface{
public void firstMethod(); // this is an abstract method
public void secondMethod(); // this throws compile error
}
Wenn wir nun das Programm ausführen, erhalten wir die folgende Warnung:
Unexpected @FunctionalInterface annotation @FunctionalInterface ^ MyFuncInterface is not a functional interface multiple non-overriding abstract methods found in interface MyFuncInterface
Es ist nicht zwingend erforderlich, @FunctionalInterface zu verwenden Anmerkung. Der Compiler betrachtet jede Schnittstelle, die der funktionalen Schnittstellendefinition entspricht, als funktionale Schnittstelle.
Wir verwenden diese Anmerkung, um sicherzustellen, dass die funktionale Schnittstelle nur eine abstrakte Methode hat.
Es kann jedoch eine beliebige Anzahl von Standard- und statischen Methoden haben, da sie eine Implementierung haben.
@FunctionalInterface
public interface MyFuncInterface{
public void firstMethod(); // this is an abstract method
default void secondMethod() { ... }
default void thirdMethod() { ... }
}
Benutzerdefinierte Anmerkungen
Es ist auch möglich, unsere eigenen benutzerdefinierten Anmerkungen zu erstellen.
Seine Syntax ist:
[Access Specifier] @interface<AnnotationName> {
DataType <Method Name>() [default value];
}
Folgendes müssen Sie über benutzerdefinierte Anmerkungen wissen:
- Anmerkungen können mit
@interfaceerstellt werden gefolgt vom Anmerkungsnamen. - Die Anmerkung kann Elemente haben, die wie Methoden aussehen, aber keine Implementierung haben.
- Der Standardwert ist optional. Die Parameter dürfen keinen Nullwert haben.
- Der Rückgabetyp der Methode kann ein Primitiv, eine Aufzählung, ein String, ein Klassenname oder ein Array dieser Typen sein.
Beispiel 6:Beispiel für benutzerdefinierte Anmerkungen
@interface MyCustomAnnotation {
String value() default "default value";
}
class Main {
@MyCustomAnnotation(value = "programiz")
public void method1() {
System.out.println("Test method 1");
}
public static void main(String[] args) throws Exception {
Main obj = new Main();
obj.method1();
}
}
Ausgabe
Test method 1
Meta-Anmerkungen
Meta-Anmerkungen sind Anmerkungen, die auf andere Anmerkungen angewendet werden.
1. @Aufbewahrung
Der @Retention Anmerkung gibt die Ebene an, bis zu der die Anmerkung verfügbar sein wird.
Seine Syntax ist:
@Retention(RetentionPolicy)
Es gibt drei Arten von Aufbewahrungsrichtlinien:
- Aufbewahrungsrichtlinie.QUELLE - Die Anmerkung ist nur auf Quellebene verfügbar und wird vom Compiler ignoriert.
- RetentionPolicy.CLASS - Die Anmerkung steht dem Compiler zur Kompilierzeit zur Verfügung, wird aber von der Java Virtual Machine (JVM) ignoriert.
- RetentionPolicy.RUNTIME - Die Anmerkung ist für die JVM verfügbar.
Zum Beispiel
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation{ ... }
2. @Dokumentiert
Standardmäßig sind benutzerdefinierte Anmerkungen nicht in der offiziellen Java-Dokumentation enthalten. Um unsere Anmerkung in die Javadoc-Dokumentation aufzunehmen, verwenden wir den @Documented Anmerkung.
Zum Beispiel
@Documented
public @interface MyCustomAnnotation{ ... }
3. @Ziel
Mit dem @Target können wir eine Anmerkung einschränken, die auf bestimmte Ziele angewendet werden soll Anmerkung.
Seine Syntax ist:
@Target(ElementType)
Der ElementType kann einen der folgenden Typen haben:
| Elementtyp | Ziel |
|---|---|
ElementType.ANNOTATION_TYPE | Anmerkungstyp |
ElementType.CONSTRUCTOR | Konstruktoren |
ElementType.FIELD | Felder |
ElementType.LOCAL_VARIABLE | Lokale Variablen |
ElementType.METHOD | Methoden |
ElementType.PACKAGE | Paket |
ElementType.PARAMETER | Parameter |
ElementType.TYPE | Jedes Element der Klasse |
Zum Beispiel
@Target(ElementType.METHOD)
public @interface MyCustomAnnotation{ ... }
In diesem Beispiel haben wir die Verwendung dieser Anmerkung nur auf Methoden beschränkt.
Hinweis: Wenn der Zieltyp nicht definiert ist, kann die Annotation für jedes Element verwendet werden.
4. @Geerbt
Standardmäßig kann ein Annotationstyp nicht von einer Oberklasse geerbt werden. Wenn wir jedoch eine Anmerkung von einer Oberklasse an eine Unterklasse erben müssen, verwenden wir den @Inherited Anmerkung.
Seine Syntax ist:
@Inherited
Zum Beispiel
@Inherited
public @interface MyCustomAnnotation { ... }
@MyCustomAnnotation
public class ParentClass{ ... }
public class ChildClass extends ParentClass { ... }
5. @Wiederholbar
Eine Anmerkung, die mit @Repeatable gekennzeichnet wurde kann mehrmals auf dieselbe Deklaration angewendet werden.
@Repeatable(Universities.class)
public @interface University {
String name();
}
Der in @Repeatable definierte Wert annotation ist die Container-Annotation. Die Containeranmerkung hat einen variablen Wert vom Array-Typ der obigen wiederholbaren Anmerkung. Hier, Universities sind der enthaltende Anmerkungstyp.
public @interface Universities {
University[] value();
}
Jetzt die @University Annotation kann mehrmals in derselben Deklaration verwendet werden.
@University(name = "TU")
@University(name = "KU")
private String uniName;
Wenn wir die Anmerkungsdaten abrufen müssen, können wir die Reflection-API verwenden.
Um Anmerkungswerte abzurufen, verwenden wir getAnnotationsByType() oder getAnnotations() Methode, die in der Reflection-API definiert ist.
Java