Annotaties definiëren: elementen en standaardwaarden
Maak aangepaste annotaties met @interface, definieer elementen met standaardwaarden en pas meta-annotaties toe.
Annotaties definiëren: elementen en standaardwaarden is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Wat zijn annotaties?
Annotaties zijn metagegevens die op klassen, methoden, velden of parameters worden toegepast. Ze veranderen het gedrag niet rechtstreeks — ze geven informatie aan compilers, frameworks of verwerkers tijdens uitvoering.
Een annotatie declareren met @interface
Gebruik @interface om een aangepaste annotatie te declareren. Elementen zien eruit als methoden. Je geeft de standaardwaarde op met default.
@interface Retry {
int times() default 3;
long delayMs() default 1000L;
Class<? extends Throwable>[] on() default {Exception.class};
}De annotatie toepassen
Pas de annotatie toe op het doel. Laat elementen met standaardwaarden weg. Wanneer slechts één element de naam value heeft, kun je de waarde zonder sleutel instellen.
@Retry(times = 5, delayMs = 500)
public void callExternalService() { ... }
// Single-element shorthand:
@interface Label { String value(); }
@Label("production")
public class App {}Typen van annotatie-elementen
Elementen kunnen alleen het volgende zijn: primitieve typen (int, long enzovoort), String, Class, een enumeratietype, een ander annotatietype of een eendimensionale array van een van deze typen.
@interface Config {
String host();
int port() default 8080;
LogLevel level() default LogLevel.INFO; // enum
Class<?> handler() default DefaultHandler.class;
String[] tags() default {};
}Meta-annotaties: @Retention
@Retention bepaalt hoelang de annotatie wordt bewaard: SOURCE (wordt door de compiler verwijderd), CLASS (staat in .class, maar niet tijdens uitvoering), RUNTIME (leesbaar via reflectie).
@Retention(RetentionPolicy.RUNTIME)
@interface Retry {
int times() default 3;
}Meta-annotaties: @Target
@Target beperkt waar de annotatie kan worden toegepast. Je kunt meerdere doelen opgeven.
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface Audited {
String description() default "";
}@Documented en @Inherited
@Documented neemt de annotatie op in Javadoc. @Inherited staat toe dat subklassen de annotatie van hun superklasse overnemen (alleen voor annotaties op klasseniveau).
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Category {
String value();
}@Repeatable-annotaties
Markeer een annotatie met @Repeatable om toe te staan dat deze meerdere keren op hetzelfde element voorkomt. Geef een containerannotatie op die een array bevat.
@Repeatable(Tags.class)
@interface Tag { String value(); }
@interface Tags { Tag[] value(); }
@Tag("fast")
@Tag("stable")
public class Service {}Standaardwaarden en elementen weglaten
Elementen met default-waarden hoef je niet op te geven bij het aanroepen. Elementen zonder standaardwaarden zijn verplicht.
@Retry // uses defaults: times=3, delayMs=1000
public void action1() {}
@Retry(times=1) // overrides only times; delayMs stays 1000
public void action2() {}Annotatie versus markerinterface
Markerinterfaces, zoals Serializable, worden gecontroleerd met instanceof en geven type-informatie door. Annotaties zijn flexibeler: ze bevatten metagegevens en kunnen elementen hebben.
Veelgebruikte ingebouwde annotaties
Ken de JDK-annotaties: @Override, @Deprecated, @FunctionalInterface, @SuppressWarnings en @SafeVarargs.
@Override
public String toString() { return "User{" + name + "}"; }
@Deprecated(since = "2.0", forRemoval = true)
public void oldMethod() {}Korte controle
Welk retentiebeleid is het enige waarmee een annotatie tijdens uitvoering leesbaar blijft?
Samenvatting
Declareer annotaties met @interface. Gebruik @Retention(RUNTIME) voor verwerking via reflectie, @Target om het gebruik te beperken en default voor optionele elementen. Met @Repeatable kun je annotaties stapelen.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Annotaties definiëren: elementen en standaardwaarden” gratis?
Ja — de volledige tekst van “Annotaties definiëren: elementen en standaardwaarden” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Annotaties definiëren: elementen en standaardwaarden”?
Maak aangepaste annotaties met @interface, definieer elementen met standaardwaarden en pas meta-annotaties toe. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Annotaties definiëren: elementen en standaardwaarden”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Annotaties definiëren: elementen en standaardwaarden
- Retentiebeleid en doeltypen
- Annotaties tijdens runtime verwerken
- Annotatieprocessors tijdens het compileren