Platform type
Nullability proveniente da Java
Platform type è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.
Kotlin incontra Java
Kotlin viene eseguito sulla JVM e invoca continuamente codice Java. Java, però, non distingue tra tipi nullable e non nulli.
Come gestisce quindi Kotlin un valore proveniente da Java? Attraverso i tipi di piattaforma.
Che cos'è un tipo di piattaforma
Un tipo di piattaforma è un tipo che Kotlin riceve da Java e la cui nullabilità è sconosciuta.
Kotlin lo scrive come String! nei messaggi di errore. Il punto esclamativo significa: potrebbe essere null oppure non nullo; Kotlin non impone una scelta.
Controlli più permissivi
Per i tipi di piattaforma Kotlin allenta i controlli sulla nullabilità. Può trattare il valore come non nullo senza che il compilatore segnali un errore.
Il compromesso è il seguente: se il valore è davvero null, si verifica un NullPointerException a runtime.
Scelta del tipo
Quando memorizza un valore di tipo piattaforma, decide come tipizzarlo:
- come non nullo
String→ comodo ma rischioso - come nullable
String?→ sicuro ed esplicito
Questo esempio Kotlin simula tale scelta.
fun fromJava(): String? = "value from Java"
fun main() {
val safe: String? = fromJava()
println(safe?.length)
}La scelta rischiosa
Se presume che il valore non sia null ma la sorgente restituisce null, l'arresto anomalo si verifica durante l'assegnazione o al primo utilizzo.
Questo è il pericolo nascosto dei tipi di piattaforma.
fun fromJava(): String? = null
fun main() {
try {
val risky: String = fromJava()!!
println(risky.length)
} catch (e: NullPointerException) {
println("Null came from the Java side")
}
}Le annotazioni aiutano
Le librerie Java possono usare annotazioni come @Nullable e @NotNull.
Quando sono presenti, Kotlin le rispetta e fornisce un vero String? o String invece di un tipo di piattaforma.
Buona pratica: supporre la nullabilità
Quando invoca codice Java privo di annotazioni, l'abitudine più sicura è trattare il risultato come nullable.
Tipizzi la variabile con ? e usi le chiamate sicure, proprio come per qualsiasi valore nullable di Kotlin.
fun fromJava(): String? = "data"
fun main() {
val value: String? = fromJava()
val length = value?.length ?: 0
println(length)
}Confini difensivi
Consideri il confine con Java non attendibile. Convalidi i valori oppure assegni loro un valore predefinito appena entrano nel codice Kotlin.
Dopo questo passaggio, il resto del codice potrà lavorare con tipi Kotlin corretti.
fun fromJava(): String? = null
fun main() {
val name = fromJava() ?: "default"
// from here on, name is a clean non-null String
println(name.uppercase())
}Perché Kotlin lo consente
Kotlin potrebbe imporre che ogni valore Java sia nullable, ma ciò renderebbe l'interoperabilità con Java inutilmente verbosa.
I tipi di piattaforma sono un compromesso pragmatico: offrono comodità, lasciando comunque la possibilità di adottare controlli rigorosi.
Riconoscere i tipi di piattaforma
Non scriverà personalmente String!. Compare solo nei suggerimenti dell'IDE e nei messaggi di errore quando passa il cursore sopra valori provenienti da Java.
Vedere il simbolo ! è il segnale per decidere deliberatamente come gestire la nullabilità.
Tutto insieme
I tipi di piattaforma fanno da ponte tra Java e Kotlin:
- Hanno una nullabilità sconosciuta, indicata come
Type! - Kotlin consente di scegliere tra nullable e non nullo
- Quando non è sicuro, supponga che il valore sia nullable per lavorare in sicurezza
- Le annotazioni eliminano ogni ambiguità
fun fromJava(): String? = "safe value"
fun main() {
val value: String? = fromJava()
println(value?.uppercase() ?: "missing")
}Verifica rapida
Verifichi la comprensione dei tipi di piattaforma.
Riepilogo
Ha imparato come la nullabilità attraversa il confine con Java:
- I tipi di piattaforma hanno una nullabilità sconosciuta
- Kotlin allenta i controlli, ma un'ipotesi errata causa un NPE a runtime
- Supponga che i valori siano nullable e assegni valori predefiniti al confine
- Le annotazioni Java ripristinano i tipi corretti
Con questo si conclude l'approfondimento sulla sicurezza rispetto ai valori null.
Domande Frequenti
La lezione «Platform type» è gratuita?
Sì — il testo completo di «Platform type» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.
Cosa imparerò in «Platform type»?
Nullability proveniente da Java Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Kotlin Academy?
Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Platform type»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?
Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.