Kotlin Academy · Lektion

Annotationen definieren

Erstellen Sie eigene Annotationen

Annotationen definieren ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Eine Annotation deklarieren

Sie definieren eine Annotation mit den Schlüsselwörtern annotation class. Die einfachste Variante enthält keine Daten und dient als Marker.

annotation class Beta

@Beta
fun newFeature() = "experimental"

fun main() {
    println(newFeature())
}

Parameter von Annotationen

Annotationen können über Konstruktorparameter Daten aufnehmen. Die zulässigen Typen sind begrenzt: primitive Typen, String, Enums, andere Annotationen, KClass und Arrays dieser Typen.

annotation class ApiVersion(val value: Int)

@ApiVersion(2)
fun endpoint() = "v2"

fun main() {
    println(endpoint())
}

@Target

@Target schränkt ein, wo Ihre Annotation angewendet werden darf. Sie übergeben einen oder mehrere AnnotationTarget-Werte wie CLASS, FUNCTION oder PROPERTY.

@Target(AnnotationTarget.FUNCTION)
annotation class Loggable

@Loggable
fun process() = "processing"

fun main() {
    println(process())
}

@Retention

@Retention legt fest, wie lange die Annotation erhalten bleibt:

SOURCE — wird vom Compiler verworfen
BINARY — bleibt in der Klassendatei erhalten, ist aber für Reflection nicht sichtbar
RUNTIME — bleibt erhalten und ist für Reflection sichtbar (die Standardeinstellung)

@Retention(AnnotationRetention.RUNTIME)
annotation class Important

@Important
class Order

fun main() {
    println("Important is readable at runtime")
}

Mehrere Ziele

Listen Sie mehrere Ziele auf, damit eine Annotation an mehr als einer Stelle verwendet werden darf. In diesem Beispiel funktioniert die Annotation sowohl für Klassen als auch für Funktionen.

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
annotation class Audited

@Audited
class Account {
    @Audited
    fun withdraw() = "ok"
}

fun main() {
    println(Account().withdraw())
}

Standardwerte für Parameter

Parameter von Annotationen können Standardwerte besitzen, sodass Aufrufer sie weglassen können. Dadurch bleiben häufige Fälle übersichtlich.

annotation class Cache(val seconds: Int = 60)

@Cache
fun cheap() = 1

@Cache(seconds = 300)
fun expensive() = 2

fun main() {
    println("" + cheap() + " " + expensive())
}

Array-Parameter

Sie können Array-Typen verwenden. Geben Sie Werte bei der Verwendung der Annotation mit der Array-Literal-Syntax [ ... ] an.

annotation class Roles(val names: Array<String>)

@Roles(["admin", "editor"])
fun restricted() = "secret"

fun main() {
    println(restricted())
}

@Repeatable

Standardmäßig darf eine Annotation pro Element nur einmal vorkommen. Kennzeichnen Sie sie mit @Repeatable, um sie mehrfach anzuwenden.

@Repeatable
annotation class Tag(val value: String)

@Tag("db")
@Tag("cache")
fun layered() = "ok"

fun main() {
    println(layered())
}

Verschachtelte Annotation-Parameter

Ein Parameter einer Annotation kann selbst eine andere Annotation sein. So können Sie strukturierte Metadaten erstellen.

annotation class Author(val name: String)
annotation class Module(val owner: Author)

@Module(Author("Grace"))
class Payments

fun main() {
    println("Nested annotation metadata defined")
}

Gute Annotationen entwerfen

Eine gut entworfene Annotation:

Hat einen klaren, einzelnen Zweck
Legt mit @Target fest, wo sie verwendet werden darf, sodass eine falsche Verwendung zu einem Kompilierfehler führt
Verwendet die Aufbewahrung mit RUNTIME nur, wenn sie für Reflection benötigt wird
Stellt sinnvolle Standardwerte bereit

Von der Definition zur Verwendung

Eine Annotation zu definieren, ist nur die halbe Arbeit. Für sich allein ist sie inaktive Metadaten. Etwas muss sie auslesen — normalerweise Reflection zur Laufzeit oder ein Annotation-Prozessor zur Kompilierzeit. Bald verwenden Sie Reflection.

Kurzer Test

Testen Sie Ihr Verständnis für das Definieren von Annotationen.

Zusammenfassung

Sie haben gelernt, Annotationen zu definieren:

annotation class mit Parametern
@Target, um die Platzierung einzuschränken
@Retention, um die Lebensdauer zu steuern
@Repeatable und Standardwerte

Als Nächstes: Typen mit Reflection untersuchen.

Häufig gestellte Fragen

Ist die Lektion „Annotationen definieren“ kostenlos?

Ja — der vollständige Text von „Annotationen definieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Annotationen definieren“?

Erstellen Sie eigene Annotationen Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Annotationen definieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy