Bruke annotasjoner
Annoter kode
Bruke annotasjoner er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.
Hva er annotasjoner?
Annotasjoner knytter metadata til kode. De endrer ikke oppførselen på egen hånd, men verktøy, kompilatorer og biblioteker leser dem for å ta avgjørelser.
Du skriver en annotasjon med @ etterfulgt av navnet, rett før elementet den gjelder for.
En første annotasjon
Standardbiblioteket inneholder flere nyttige annotasjoner. @Deprecated markerer kode som ikke lenger bør brukes, og viser en advarsel på kallstedet.
@Deprecated("Use newGreet() instead")
fun greet() = "Hi"
fun newGreet() = "Hello"
fun main() {
println(newGreet())
}Annotasjoner med argumenter
Annotasjoner kan ta argumenter, skrevet som konstruktørparametere. @Deprecated godtar en melding og eventuelt et ReplaceWith-hint.
@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))
}Undertrykke advarsler
@Suppress ber kompilatoren om å undertrykke bestemte advarsler for det annoterte elementet. Du sender advarselsnavnene som strenger.
@Suppress("UNUSED_VARIABLE")
fun main() {
val unused = 42
println("Runs without the unused-variable warning")
}JvmStatic og venner
Noen annotasjoner påvirker hvordan Kotlin kompilerer til JVM. @JvmStatic, @JvmField og @JvmName styrer bytekoden slik at Java-kallere får mer brukervennlige API-er.
Disse gjør ingenting i ren Kotlin-kode, men er viktige for interoperabilitet.
class Math {
companion object {
@JvmStatic
fun square(x: Int) = x * x
}
}
fun main() {
println(Math.square(5))
}Plasseringsmål for annotasjoner
En egenskap kan generere flere JVM-elementer: et felt, en getter, en setter og konstruktørparametere. Plasseringsmål angir hvor en annotasjon skal plasseres.
Syntaks: @get:, @set:, @field:, @param:.
class User(@get:JvmName("fetchName") val name: String)
fun main() {
val u = User("Ada")
println(u.name)
}Throws for Java-interoperabilitet
Kotlin har ingen kontrollerte unntak, så Java-kallere ser aldri throws-klausuler med mindre du legger til @Throws. Den registrerer unntakstypen i bytekodesignaturen.
import java.io.IOException
@Throws(IOException::class)
fun readData(): String {
return "data"
}
fun main() {
println(readData())
}Flere annotasjoner
Du kan legge flere annotasjoner på ett element. Hver annotasjon står på sin egen linje eller skilles med mellomrom. Rekkefølgen har ingen betydning.
@Deprecated("old")
@Suppress("DEPRECATION")
fun legacy() = "still here"
fun main() {
println(legacy())
}Annotasjoner på uttrykk
Annotasjoner kan også gjelde uttrykk og lokale deklarasjoner, ikke bare funksjoner eller klasser på toppnivå. Dette er vanlig med @Suppress inne i en funksjonskropp.
fun main() {
@Suppress("UNUSED_VARIABLE")
val temp = computeOnce()
println("Done")
}
fun computeOnce() = 99OptIn og eksperimentelle API-er
Biblioteker merker ustabile API-er med egendefinerte opt-in-annotasjoner. For å bruke dem bekrefter du at du aksepterer risikoen med @OptIn(SomeApi::class) eller ved å videreføre annotasjonen.
Dette gjør eksperimentelle funksjoner eksplisitte i stedet for utilsiktede.
fun main() {
// @OptIn would appear here when calling an experimental function
println("Opt-in keeps unstable APIs visible")
}Hvorfor bruke annotasjoner?
Annotasjoner lar deg kommunisere hensikt til verktøy: kompilatorer advarer ved bruk av foreldede kall, serialiseringsbiblioteker kobler felt til data, testrammeverk finner testmetoder, og DI-rammeverk kobler sammen avhengigheter.
- Metadata, ikke logikk
- Leses ved kompilering eller kjøring
- Holder konfigurasjonen nær koden
Kort sjekk
Test forståelsen din av bruk av annotasjoner.
Oppsummering
Du lærte å bruke innebygde annotasjoner:
@Deprecated,@Suppress,@Throws- JVM-interoperabilitet:
@JvmStatic,@JvmName - Plasseringsmål som
@get:og@field: - Opt-in for eksperimentelle API-er
Deretter skal du definere dine egne annotasjoner.
Lær deg Kotlin med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 51
- Leksjoner
- 203
Ofte stilte spørsmål
Er leksjonen «Bruke annotasjoner» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Bruke annotasjoner», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Bruke annotasjoner»?
Annoter kode Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Kotlin Academy?
Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Bruke annotasjoner»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?
Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Bruke annotasjoner
- Definere annotasjoner
- Grunnleggende refleksjon
- Praktisk refleksjon