Java Annotatie is een tag die de metagegevens d.w.z. gekoppeld aan klasse, interface, methoden of velden om aanvullende informatie aan te geven die kan worden gebruikt door de Java-compiler en JVM.

Annotaties in Java worden gebruikt om aanvullende informatie te verschaffen, dus het is een alternatieve optie voor XML- en Java-markeringsinterfaces.

Eerst zullen we enkele ingebouwde annotaties leren, daarna gaan we verder met het maken en gebruiken van aangepaste annotaties.

Ingebouwde Java-annotaties

Er zijn verschillende ingebouwde annotaties in Java. Sommige annotaties worden toegepast op Java-code en andere op andere annotaties.

Ingebouwde Java-annotaties gebruikt in Java-code

• @Overschrijven
• @SuppressWaarschuwingen
• @Verouderd

Ingebouwde Java-annotaties die in andere annotaties worden gebruikt

• @Doel
• @Behoud
• @Geërfd
• @Gedocumenteerd

Ingebouwde annotaties begrijpen

Laten we eerst de ingebouwde annotaties begrijpen.

@Overschrijven

@Override-annotatie zorgt ervoor dat de subklassemethode de bovenliggende klassemethode overschrijft. Als dit niet het geval is, treedt er een compileerfout op.

Soms maken we een domme fout, zoals spelfouten enz. Het is dus beter om de annotatie @Override te markeren, die de zekerheid biedt dat de methode wordt overschreven.

jaar dat de computer werd uitgevonden

 class Animal{ void eatSomething(){System.out.println('eating something');} } class Dog extends Animal{ @Override void eatsomething(){System.out.println('eating foods');}//should be eatSomething } class TestAnnotation1{ public static void main(String args[]){ Animal a=new Dog(); a.eatSomething(); }} 

 Output:Comple Time Error 

@SuppressWaarschuwingen

@SuppressWarnings-annotatie: wordt gebruikt om waarschuwingen van de compiler te onderdrukken.

 import java.util.*; class TestAnnotation2{ @SuppressWarnings('unchecked') public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('sonoo'); list.add('vimal'); list.add('ratan'); for(Object obj:list) System.out.println(obj); }} 

 Now no warning at compile time. 

Als u de annotatie @SuppressWarnings('unchecked') verwijdert, wordt er tijdens het compileren een waarschuwing weergegeven omdat we een niet-generieke verzameling gebruiken.

@Verouderd

De annoatie @Deprecated geeft aan dat deze methode is verouderd, zodat de compiler een waarschuwing afdrukt. Het informeert de gebruiker dat het in toekomstige versies kan worden verwijderd. Het is dus beter om dergelijke methoden niet te gebruiken.

json-bestand

 class A{ void m(){System.out.println('hello m');} @Deprecated void n(){System.out.println('hello n');} } class TestAnnotation3{ public static void main(String args[]){ A a=new A(); a.n(); }} 

Tijdens het compileren:

 Note: Test.java uses or overrides a deprecated API. <br> Note: Recompile with -Xlint:deprecation for details. 

Tijdens runtime:

 hello n 

Aangepaste Java-annotaties

Aangepaste Java-annotaties of Java Door de gebruiker gedefinieerde annotaties zijn eenvoudig te maken en te gebruiken. De @koppel element wordt gebruikt om een ​​annotatie te declareren. Bijvoorbeeld:

 @interface MyAnnotation{} 

Hier is MijnAnnotatie de aangepaste annotatienaam.

Aandachtspunten voor aangepaste Java-annotatiehandtekening

Er zijn een paar punten die de programmeur moet onthouden.

1. De methode mag geen throws-clausules bevatten
2. De methode moet een van de volgende items retourneren: primitieve gegevenstypen, String, Class, enum of array van deze gegevenstypen.
3. De methode mag geen parameter hebben.
4. We moeten @ net vóór het interface-trefwoord toevoegen om de annotatie te definiëren.
5. Het kan een standaardwaarde aan de methode toewijzen.

Soorten annotaties

Er zijn drie soorten annotaties.

1. Markerannotatie
2. Annotatie met één waarde
3. Annotatie met meerdere waarden

1) Markerannotatie

Een annotatie die geen methode heeft, wordt markerannotatie genoemd. Bijvoorbeeld:

string naar geheel getal java

 @interface MyAnnotation{} 

De @Override en @Deprecated zijn markeringsannotaties.

2) Annotatie met één waarde

Een annotatie die één methode heeft, wordt annotatie met één waarde genoemd. Bijvoorbeeld:

 @interface MyAnnotation{ int value(); } 

We kunnen ook de standaardwaarde opgeven. Bijvoorbeeld:

 @interface MyAnnotation{ int value() default 0; } 

Annotatie met één waarde toepassen

Laten we de code bekijken om de annotatie met één waarde toe te passen.

 @MyAnnotation(value=10) 

De waarde kan van alles zijn.

3) Annotatie met meerdere waarden

Een annotatie die meer dan één methode heeft, wordt Multi-Value-annotatie genoemd. Bijvoorbeeld:

 @interface MyAnnotation{ int value1(); String value2(); String value3(); } } 

We kunnen ook de standaardwaarde opgeven. Bijvoorbeeld:

 @interface MyAnnotation{ int value1() default 1; String value2() default ''; String value3() default 'xyz'; } 

Annotatie met meerdere waarden toepassen

Laten we de code bekijken om de annotatie met meerdere waarden toe te passen.

 @MyAnnotation(value1=10,value2='Arun Kumar',value3='Ghaziabad') 

Ingebouwde annotaties gebruikt in aangepaste annotaties in Java

• @Doel
• @Behoud
• @Geërfd
• @Gedocumenteerd

@Doel

@Doel tag wordt gebruikt om aan te geven bij welk type de annotatie wordt gebruikt.

De java.lang.annotatie. Elementtype enum declareert veel constanten om het type element te specificeren waarop annotatie moet worden toegepast, zoals TYPE, METHOD, FIELD etc. Laten we de constanten van ElementType enum bekijken:

Voorbeeld om annoatie voor een klasse op te geven

 @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Voorbeeld om annotatie voor een klasse, methoden of velden op te geven

 @Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD}) @interface MyAnnotation{ int value1(); String value2(); } 

@Behoud

@Behoud annotatie wordt gebruikt om aan te geven tot welk niveau annotatie beschikbaar zal zijn.

dfa-voorbeelden

Voorbeeld om het Retentiebeleid op te geven

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface MyAnnotation{ int value1(); String value2(); } 

Voorbeeld van aangepaste annotatie: annotatie maken, toepassen en openen

Laten we een eenvoudig voorbeeld bekijken van het maken, toepassen en openen van annotaties.

Bestand: Test.java

 //Creating annotation import java.lang.annotation.*; import java.lang.reflect.*; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface MyAnnotation{ int value(); } //Applying annotation class Hello{ @MyAnnotation(value=10) public void sayHello(){System.out.println('hello annotation');} } //Accessing annotation class TestCustomAnnotation1{ public static void main(String args[])throws Exception{ Hello h=new Hello(); Method m=h.getClass().getMethod('sayHello'); MyAnnotation manno=m.getAnnotation(MyAnnotation.class); System.out.println('value is: '+manno.value()); }} 

 Output:value is: 10 

Hoe worden ingebouwde annotaties gebruikt in een realistisch scenario?

In het echte scenario hoeft de Java-programmeur alleen annotatie toe te passen. Hij/zij hoeft geen annotatie te maken en te openen. Het maken en openen van annotaties wordt uitgevoerd door de implementatieprovider. Namens de annotatie voert de Java-compiler of JVM enkele aanvullende bewerkingen uit.

@Geërfd

Standaard worden annotaties niet overgenomen naar subklassen. De annotatie @Inherited markeert de annotatie die moet worden overgenomen naar subklassen.

 @Inherited @interface ForEveryone { }//Now it will be available to subclass also @interface ForEveryone { } class Superclass{} class Subclass extends Superclass{} 

@Gedocumenteerd

De @Documented Markeert de annotatie voor opname in de documentatie.