Java Annotatie typen

Deze tutorial behandelt Java annotaties – voorgedefinieerde, aangepaste, en meta-annotaties – met duidelijke voorbeelden.

Java annotaties zijn metadata die elementen in je broncode beschrijven. Het Java SE platform levert een set standaard annotaties, en ontwikkelaars kunnen aangepaste maken afgestemd op hun projecten. Annotaties kunnen ook zelf geannoteerd worden, wat vormt wat bekend staat als meta-annotaties.

Annotaties vallen in drie categorieën:

1. Voorgedefinieerde annotaties – ingebouwd in het Java platform.
2. Aangepaste annotaties – gebruiker-gedefinieerd voor specifieke behoeften.
3. Meta-annotaties – annotaties toegepast op andere annotaties.

Voorgedefinieerde annotatie typen

1. @Deprecated

De @Deprecated marker signaleert dat een klasse, methode, veld, of ander element verouderd is en een nieuwere alternatief heeft. De compiler geeft een waarschuwing wanneer een deprecated element gebruikt wordt.

Syntax:

@Deprecated public void oudeMethode() { ... }

Javadoc biedt de @deprecated tag voor documentatie:

/** * @deprecated * Gebruik {@link #nieuweMethode()} in plaats daarvan. */ @Deprecated public void oudeMethode() { ... }

Voorbeeld

class Main { /** * @deprecated * Deze methode is deprecated en vervangen door nieuweMethode() */ @Deprecated public static void deprecatedMethode() { System.out.println("Deprecated methode"); } public static void main(String[] args) { deprecatedMethode(); } }

Uitvoer

Deprecated methode

2. @Override

De @Override annotatie geeft aan dat een methode bedoeld is om een methode van een superklasse of interface te overriden. Hoewel niet verplicht, vangt het fouten zoals mismatched handtekeningen tijdens compile-time.

Voorbeeld

class Dier { public void toon() { System.out.println("Ik ben een dier"); } } class Hond extends Dier { @Override public void toon() { System.out.println("Ik ben een hond"); } public void printBericht() { toon(); } } class Main { public static void main(String[] args) { Hond hond1 = new Hond(); hond1.printBericht(); } }

Uitvoer

Ik ben een hond

3. @SuppressWarnings

Deze annotatie instructeert de compiler om specifieke waarschuwingscategorieën te negeren. Veelvoorkomende categorieën zijn deprecation en unchecked.

Gebruik:

@SuppressWarnings("deprecation")

Meerdere categorieën:

@SuppressWarnings({"deprecation", "unchecked"})

Voorbeeld

class Main { @Deprecated public static void deprecatedMethode() { System.out.println("Deprecated methode"); } @SuppressWarnings("deprecation") public static void main(String[] args) { Main depObj = new Main(); depObj.deprecatedMethode(); } }

Uitvoer

Deprecated methode

4. @SafeVarargs

Toegepast op final, static, of private methoden en constructors, beweren @SafeVarargs dat de methode geen onveilige operaties uitvoert op zijn varargs parameter. Dit verwijdert unchecked waarschuwingen gerelateerd aan varargs.

Voorbeeld

import java.util.*; class Main { @SafeVarargs private static void toonLijst(List... lijsten) { for (List lijst : lijsten) { System.out.println(lijst); } } public static void main(String[] args) { List universiteitLijst = Arrays.asList("Tribhuvan Universiteit", "Kathmandu Universiteit"); List programmeerTalenn = Arrays.asList("Java", "C"); toonLijst(universiteitLijst, programmeerTalenn); } }

Uitvoer

[Tribhuvan Universiteit, Kathmandu Universiteit] [Java, C]

5. @FunctionalInterface

Geïntroduceerd in Java 8, deze annotatie wijst een interface aan als een functionele interface – een interface met een enkele abstracte methode. De compiler verifieert deze constraint.

Voorbeeld

@FunctionalInterface public interface MijnFuncInterface { void eersteMethode(); // abstract }

Het toevoegen van een tweede abstracte methode triggert een compilatiefout:

@FunctionalInterface public interface MijnFuncInterface { void eersteMethode(); void tweedeMethode(); // compile-time error }

Meerdere default of static methoden zijn toegestaan.

@FunctionalInterface public interface MijnFuncInterface { void eersteMethode(); default void tweedeMethode() { /* ... */ } default void derdeMethode() { /* ... */ } }

Aangepaste annotaties

Ontwikkelaars kunnen annotaties creëren die passen bij applicatie-specifieke vereisten. De syntax gebruikt @interface en kan element-methoden met optionele default waarden bevatten.

Syntax

@interface AnnotatieNaam { ElementType elementNaam() default defaultValue; }

Voorbeeld

@interface MijnAangepasteAnnotatie { String value() default "default waarde"; } class Main { @MijnAangepasteAnnotatie(value = "programiz") public void methode1() { System.out.println("Test methode 1"); } public static void main(String[] args) { new Main().methode1(); } }

Uitvoer

Test methode 1

Meta annotaties

Meta-annotaties configureren hoe andere annotaties zich gedragen.

1. @Retention

Definieert het bereik van een annotatie's zichtbaarheid: SOURCE, CLASS, of RUNTIME.

@Retention(RetentionPolicy.RUNTIME) public @interface MijnAnnotatie { }

2. @Documented

Zorgt ervoor dat de annotatie verschijnt in gegenereerde Javadoc.

@Documented public @interface MijnAnnotatie { }

3. @Target

Beperkt de annotatie tot specifieke programma-elementen.

@Target(ElementType.METHOD) public @interface MijnAnnotatie { }

Element types omvatten ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE.

4. @Inherited

Staat toe dat een subklasse een annotatie erft die aanwezig is op een superklasse.

@Inherited public @interface MijnAnnotatie { }

5. @Repeatable

Staat toe dat een annotatie meerdere keren op hetzelfde element toegepast wordt. Vereist een container annotatie.

@Repeatable(Universiteiten.class) public @interface Universiteit { String naam(); } public @interface Universiteiten { Universiteit[] value(); }

Gebruik:

@Universiteit(naam = "TU") @Universiteit(naam = "KU") private String uniNaam;

Om annotatie data tijdens runtime te benaderen, gebruik de Reflectie API's getAnnotationsByType() of getAnnotations() methoden.