Introductie Annotaties in Java
Annotaties werden geïntroduceerd of kwamen beschikbaar in de 1.5-versie van de Java Development Kit (JDK). Annotaties in Java bieden meer informatie over de gegevens in de codestructuur, dat wil zeggen gegevens over gegevens die ook wel metagegevens worden genoemd.
Wat zijn annotaties in Java?
Annotaties helpen bij het definiëren van metagegevens in code op een gestandaardiseerde manier. Ook helpen annotaties bij het geven van instructies aan uw java-compiler om te volgen tijdens het compileren van die java-code.
Bij het gebruik van de annotaties gebruiken we het teken '@' en vervolgens gevolgd door de naam van uw annotatie, zodat de compiler deze als een annotatie behandelt. Het is belangrijk op te merken dat de annotaties kunnen worden toegevoegd voordat-
- Een klasseverklaring
- Aangifte van een lidvariabele
- Een constructeursverklaring
- Een methodeverklaring
- Een parameterverklaring
- Een lokale variabele verklaring.
Belangrijke punten om te onthouden zijn dat alle annotaties de interface java.lang.annotation.Annotation uitbreiden. Ook kunnen annotaties geen uitgebreide clausule bevatten.
Ingebouwde Java-annotaties
In Java zijn er ingebouwde annotaties zoals @Override, @Deprecated, @SuppressWarnings die zijn ontworpen voor een specifiek doel en worden gebruikt in een van de bovenstaande situaties, bijvoorbeeld alleen voor de klasse of alleen voor de methode, enz.
Voorbeeld # 1 - Overschrijven
class Dad (
public void say() (
System.out.println("Do your homework");
)
)
public class Child extends Dad (
@Override
public void say()(
System.out.println("I wanna play");
)
public static void main(String args())(
Dad daddy = new Child();
daddy.say();
)
)
uitgang
Voorbeeld # 2 - Vervallen
public class Outdated
(
@Deprecated
public void oldShow()
(
System.out.println("This Method is deprecated"); )
public static void main(String args())
(
Outdated od = new Outdated ();
od.oldShow();
)
)
uitgang
Meta-annotaties
Er zijn vijf soorten meta-annotaties:
- Gedocumenteerd - Het informeert dat het lid of de variabele of klasse die deze annotatie gebruikt, moet worden gedocumenteerd door Javadoc of andere vergelijkbare beschikbare hulpmiddelen.
- Doel - Het wordt gebruikt om aan te geven bij welk type de annotatie wordt gebruikt. Het wordt meestal gebruikt in combinatie met uw aangepaste annotaties.
- Overgenomen - het markeert de annotatie die moet worden geërfd aan de subklasse.
- Retentie - geeft aan hoe lang annotaties met het geannoteerde type moeten worden bewaard. Er is het Retentiebeleid-argument nodig waarvan de mogelijke waarden zijn: BRON, KLASSE en RUNTIME.
- Herhaalbaar - Hiermee wordt aangegeven dat de annotatietypen waarvan de verklaring annoteert, herhaalbaar zijn.
Voorbeeld - Documentatie en retentie
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@interface RSample (
String rentent();
)
@Documented
@interface DSample (
String doc();
)
public class MetaAnnotate (
public static void main(String arg())
(
new MetaAnnotate().rentent();
new MetaAnnotate().doc();
)
@RSample (rentent="Meta Info R")
public void rentent() (
System.out.println("Retention Policy Applied");
)
@DSample(doc="Meta Info D")
public void doc() (
System.out.println("Code Documented with the value");
)
)
uitgang
Uitleg
RetentionPolicy.RUNTIME - Deze waarde geeft aan dat de annotatiewaarde tijdens runtime beschikbaar moet zijn voor inspectie via Java-reflectie.
Voer de Javadoc-opdracht uit om de documentatie van uw code te bekijken.
Soorten annotaties
Er zijn drie categorieën annotaties en er zijn de volgende:
1. Markerannotaties - Dit soort annotaties worden gebruikt als een verklaring om de ontwikkelaar te informeren waar de onderstaande functie of klasse over gaat, dat wil zeggen dat het extra informatie deelt over de functie of klasse, of de functie een andere functie vervangt of de functie is verouderd, etc. @Override, @Deprecated worden beschouwd als markeringsannotaties.
Voorbeeld: DemoAnnotation ()
2. Annotaties met één waarde - Dit type annotatie heeft waarde nodig om die waarde op te geven voor dat lid waarvoor de annotatie vóór wordt geplaatst en daarom hoeft de naam van dat lid niet te worden opgegeven.
Voorbeeld: DemoAnnotation ("custId123")
3. Volledige annotaties - Bij dit soort annotaties worden meerdere waarden, paren, leden gebruikt.
Voorbeeld: DemoAnnotation (categorie = "Speelgoed", waarde = 1500)
Op maat
Aangepaste annotaties worden gemaakt door de gebruikersinterface, gevolgd door een annotatienaam zoals we in het onderstaande voorbeeld zullen zien.
Bestand 1: Aangepaste annotatie gedefinieerd
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target((ElementType.TYPE, ElementType.METHOD))
@Retention(RetentionPolicy.RUNTIME)
@interface Magicians
(
String Wizard() default "Reynolds";
String House() default "Green";
)
@Magicians
public class Magician
(
@Magicians(Wizard = "Harry Potter", House = "Red")
public String getString() ( return null; )
)
Bestand 2: Hoofdklasse die de Custom Annotation Class aanroept
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
public class MyCustomAnnotation
(
public static void main(String() args) throws NoSuchMethodException, SecurityException
(
new Magician();
Class magic = Magician.class;
readAnnotationOn(magic);
Method method = magic.getMethod("getString", new Class()());
readAnnotationOn(method);
)
static void readAnnotationOn(AnnotatedElement element)
(
try
(
System.out.println("\n Find annotations on " + element.getClass().getName());
Annotation() annotations = element.getAnnotations();
for (Annotation annotation : annotations)
(
if (annotation instanceof Magicians)
(
Magicians mData = (Magicians) annotation;
System.out.println("Wizard Name :" + mData.Wizard());
System.out.println("Wizard House Color :" + mData.House());
)
)
) catch (Exception e)
(
e.printStackTrace();
)
)
)
uitgang
Conclusie
In dit artikel hebben we geleerd over wat Java-annotaties zijn en hun typen met voorbeelden, en we zagen voorbeelden van ingebouwde annotaties die door Java werden geleverd en codeerden onze aangepaste annotaties.
We hebben geleerd dat annotaties nuttig zijn bij het standaardiseren van de code en ook helpen om de code en de structuur ervan beter te begrijpen.
Aanbevolen artikelen
Dit is een handleiding voor Java-annotaties. Hier bespreken we hoe ingebouwde Java-annotaties met de gegeven voorbeelden en uitgangen. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Variabelen in Java
- Patronen in Java
- Snel sorteren op Java
- Beste Java-compilers
- instanceOf in Java met voorbeeld