Kotlin Academy · Lektion

Annotationen verwenden

Annotieren Sie Code

Annotationen verwenden ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was sind Annotationen?

Annotationen fügen Code Metadaten hinzu. Sie ändern das Verhalten nicht selbst, aber Werkzeuge, Compiler und Bibliotheken lesen sie aus, um Entscheidungen zu treffen.

Sie schreiben eine Annotation mit @, gefolgt von ihrem Namen, direkt vor das Element, auf das sie angewendet wird.

Eine erste Annotation

Die Standardbibliothek enthält mehrere nützliche Annotationen. @Deprecated kennzeichnet Code, der nicht mehr verwendet werden sollte, und zeigt an der Aufrufstelle eine Warnung an.

@Deprecated("Use newGreet() instead")
fun greet() = "Hi"

fun newGreet() = "Hello"

fun main() {
    println(newGreet())
}

Annotationen mit Argumenten

Annotationen können Argumente annehmen, die wie Konstruktorparameter geschrieben werden. @Deprecated akzeptiert eine Meldung und optional einen Hinweis in Form von ReplaceWith.

@Deprecated(
    message = "Renamed for clarity",
    replaceWith = ReplaceWith("sum(a, b)")
)
fun add(a: Int, b: Int) = a + b

fun sum(a: Int, b: Int) = a + b

fun main() {
    println(sum(2, 3))
}

Warnungen unterdrücken

@Suppress weist den Compiler an, bestimmte Warnungen für das annotierte Element zu unterdrücken. Sie übergeben die Namen der Warnungen als Zeichenketten.

@Suppress("UNUSED_VARIABLE")
fun main() {
    val unused = 42
    println("Runs without the unused-variable warning")
}

JvmStatic und Verwandte

Einige Annotationen beeinflussen, wie Kotlin für die JVM kompiliert wird. @JvmStatic, @JvmField und @JvmName steuern den Bytecode, sodass Java-Aufrufer auf benutzerfreundlichere APIs zugreifen können.

Für reinen Kotlin-Code sind sie wirkungslos, für die Interoperabilität jedoch wichtig.

class Math {
    companion object {
        @JvmStatic
        fun square(x: Int) = x * x
    }
}

fun main() {
    println(Math.square(5))
}

Use-Site-Targets für Annotationen

Aus einer Property können mehrere JVM-Elemente entstehen: ein Feld, ein Getter, ein Setter und Konstruktorparameter. Use-Site-Targets legen fest, wo eine Annotation angewendet werden soll.

Syntax: @get:, @set:, @field:, @param:.

class User(@get:JvmName("fetchName") val name: String)

fun main() {
    val u = User("Ada")
    println(u.name)
}

Throws für Java-Interop

Kotlin kennt keine geprüften Ausnahmen, daher sehen Java-Aufrufer niemals throws-Klauseln, es sei denn, Sie fügen @Throws hinzu. Dadurch wird der Ausnahmetyp in der Bytecode-Signatur vermerkt.

import java.io.IOException

@Throws(IOException::class)
fun readData(): String {
    return "data"
}

fun main() {
    println(readData())
}

Mehrere Annotationen

Sie können mehrere Annotationen auf ein Element setzen. Jede Annotation steht in einer eigenen Zeile oder sie werden durch Leerzeichen getrennt. Die Reihenfolge spielt keine Rolle.

@Deprecated("old")
@Suppress("DEPRECATION")
fun legacy() = "still here"

fun main() {
    println(legacy())
}

Annotationen auf Ausdrücken

Annotationen können auch auf Ausdrücke und lokale Deklarationen angewendet werden, nicht nur auf Funktionen oder Klassen der obersten Ebene. Das ist innerhalb eines Funktionsrumpfs bei @Suppress üblich.

fun main() {
    @Suppress("UNUSED_VARIABLE")
    val temp = computeOnce()
    println("Done")
}

fun computeOnce() = 99

OptIn und experimentelle APIs

Bibliotheken kennzeichnen instabile APIs mit benutzerdefinierten Opt-in-Annotationen. Um sie zu verwenden, bestätigen Sie das Risiko mit @OptIn(SomeApi::class) oder geben die Annotation weiter.

So bleiben experimentelle Funktionen ausdrücklich aktiviert und werden nicht versehentlich verwendet.

fun main() {
    // @OptIn would appear here when calling an experimental function
    println("Opt-in keeps unstable APIs visible")
}

Warum annotieren?

Mit Annotationen können Sie Werkzeugen Ihre Absicht mitteilen: Compiler warnen bei veralteten Aufrufen, Serialisierungsbibliotheken ordnen Felder zu, Test-Frameworks finden Testmethoden und DI-Frameworks verdrahten Abhängigkeiten.

Metadaten statt Logik
Zur Kompilierzeit oder Laufzeit ausgelesen
Konfiguration bleibt nahe am Code

Kurzer Test

Testen Sie Ihr Verständnis für die Verwendung von Annotationen.

Zusammenfassung

Sie haben gelernt, integrierte Annotationen zu verwenden:

@Deprecated, @Suppress, @Throws
JVM-Interop: @JvmStatic, @JvmName
Use-Site-Targets wie @get: und @field:
Opt-in für experimentelle APIs

Als Nächstes definieren Sie eigene Annotationen.

Häufig gestellte Fragen

Ist die Lektion „Annotationen verwenden“ kostenlos?

Ja — der vollständige Text von „Annotationen verwenden“ 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 verwenden“?

Annotieren Sie Code 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 1 von 4.

Wie lange dauert die Lektion „Annotationen verwenden“?

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