Limitazioni
Scopra cosa non possono fare le value class
Limitazioni è 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.
Conoscere i limiti
Le value class sono potenti, ma soggette a vincoli. Comprenderne i limiti aiuta a scegliere lo strumento giusto ed evitare sorprese.
Esattamente una proprietà
Una value class racchiude un solo valore. Per raggruppare più campi è necessaria una classe normale o una data class.
// @JvmInline value class Range(val lo: Int, val hi: Int) // not allowed
data class Range(val lo: Int, val hi: Int)
fun main() {
println(Range(1, 10))
}Nessuno stato aggiuntivo oltre al valore
Le value class non possono avere campi di supporto oltre alla singola proprietà del costruttore. Non è consentito aggiungere uno stato var con un campo di supporto.
@JvmInline
value class Counter(val value: Int) {
// val cached: Int = value * 2 // not allowed: extra backing field
val doubled: Int get() = value * 2 // computed is fine
}
fun main() {
println(Counter(3).doubled)
}Nessuna ereditarietà
Le value class sono implicitamente final. Non possono estendere altre classi né essere estese. Possono soltanto implementare interfacce.
interface Named { val label: String }
@JvmInline
value class Tag(val text: String) : Named {
override val label: String get() = text
}
fun main() {
println(Tag("urgent").label)
}Il boxing reintroduce un costo
La promessa di un overhead nullo viene meno quando il valore viene usato come tipo nullable, generico o di un'interfaccia. Il compilatore lo sottopone quindi a boxing, trasformandolo in un oggetto reale.
@JvmInline
value class Id(val raw: Int)
fun main() {
val list: List<Id> = listOf(Id(1), Id(2)) // boxed inside the list
println(list.map { it.raw })
}Nessuna identità
Le value class non hanno un'identità referenziale stabile. L'uguaglianza referenziale con === non ha significato e non possono essere usate dove l'identità dell'oggetto è importante, ad esempio come lock di sincronizzazione.
@JvmInline
value class Code(val value: Int)
fun main() {
val a = Code(5)
val b = Code(5)
println(a == b) // structural equality works
}Non può essere lateinit né delegata
Non è possibile applicare lateinit al valore sottostante e le value class non supportano la delega delle proprietà sul loro unico campo. Il valore deve essere impostato nel costruttore.
@JvmInline
value class Slug(val value: String)
fun main() {
val s = Slug("hello-world") // must be provided up front
println(s.value)
}Name mangling sulla JVM
Sulla JVM, le funzioni che accettano parametri di una value class ricevono nomi sottoposti a name mangling nel bytecode per evitare conflitti. Questo complica l'interoperabilità con Java: i chiamanti Java potrebbero non visualizzarle correttamente.
@JvmInline
value class Hz(val value: Int)
fun tune(freq: Hz) = freq.value
fun main() {
println(tune(Hz(440))) // simple from Kotlin; mangled from Java
}Non per wrapper con più campi
Se si desiderano due proprietà, una value class è lo strumento sbagliato. Si ricorra a una data class, accettando l'allocazione in cambio di una struttura più ricca.
data class Coordinate(val lat: Double, val lng: Double)
fun main() {
println(Coordinate(41.0, 29.0))
}Riepilogo dei limiti
Le value class non possono:
- Contenere più di una proprietà
- Avere campi di supporto aggiuntivi o
lateinit - Ereditare da classi o essere estese da classi
- Offrire un'identità referenziale
- Evitare sempre il boxing
Scegliere con criterio
Usi una value class per un singolo valore convalidato e type-safe. Usi una data class per dati raggruppati. Usi un type alias per una pura maggiore leggibilità, senza sicurezza aggiuntiva. Ognuno ha il suo impiego.
Verifica rapida
Verifichi la sua comprensione dei limiti delle value class.
Riepilogo
Ha imparato i limiti delle value class:
- Una sola proprietà, senza campi di supporto aggiuntivi
- Nessuna ereditarietà e nessuna identità
- Il boxing ricompare per l'uso nullable, generico o come interfaccia
- Il name mangling sulla JVM complica l'interoperabilità con Java
Scelga lo strumento in base all'esigenza.
Impara Kotlin con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Limitazioni» è gratuita?
Sì — il testo completo di «Limitazioni» è 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 «Limitazioni»?
Scopra cosa non possono fare le value class 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 «Limitazioni»?
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.
Tutte le lezioni di questo corso
- Alias di tipo
- Inline value class
- Casi d'uso
- Limitazioni