Kotlin Academy · Lezione

Inline value class

Esegua il wrapping senza overhead

Inline value class è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Il problema del wrapping

Avvolgere un tipo primitivo in una classe aggiunge sicurezza sui tipi, ma normalmente comporta un'allocazione nell'heap. Le value class offrono la stessa sicurezza mentre il compilatore elimina il wrapper quando possibile.

Dichiarare una value class

Contrassegni una classe con @JvmInline value class e una sola proprietà nel costruttore primario. Si comporta come un tipo distinto.

@JvmInline
value class Password(val value: String)

fun main() {
    val p = Password("secret")
    println(p.value)
}

Un tipo distinto

A differenza di un type alias, una value class è un tipo separato. Non è possibile passare accidentalmente una String dove è previsto un Password.

@JvmInline
value class Password(val value: String)

fun login(p: Password) = println("login with " + p.value)

fun main() {
    login(Password("hunter2"))
}

Nessun overhead

A runtime, il compilatore solitamente esegue l'inlining del valore sottostante, quindi non viene allocato alcun oggetto aggiuntivo. Nella maggior parte dei percorsi del codice, una Password è rappresentata come una semplice String.

@JvmInline
value class Meters(val amount: Double)

fun main() {
    val d = Meters(5.0)
    println(d.amount) // stored inline as a Double
}

Metodi e proprietà

Le value class possono avere funzioni e proprietà calcolate, proprio come le classi normali.

@JvmInline
value class Celsius(val degrees: Double) {
    fun toFahrenheit() = degrees * 9 / 5 + 32
}

fun main() {
    println(Celsius(100.0).toFahrenheit())
}

Blocchi init per la convalida

Un blocco init consente di convalidare il valore racchiuso al momento della costruzione, garantendo che ogni istanza sia valida.

@JvmInline
value class Percentage(val value: Int) {
    init {
        require(value in 0..100) { "out of range" }
    }
}

fun main() {
    println(Percentage(75).value)
}

Proprietà calcolate

È possibile aggiungere proprietà calcolate derivate dall'unico valore memorizzato, mantenendo la logica vicina al tipo.

@JvmInline
value class Seconds(val value: Int) {
    val asMinutes: Double get() = value / 60.0
}

fun main() {
    println(Seconds(120).asMinutes)
}

Implementare interfacce

Le value class possono implementare interfacce, consentendo un utilizzo polimorfico. Nota: in questo caso potrebbe essere necessario eseguire il boxing quando vengono trattate come il tipo dell'interfaccia.

interface Describable {
    fun describe(): String
}

@JvmInline
value class Money(val cents: Int) : Describable {
    override fun describe() = "$" + cents / 100.0
}

fun main() {
    println(Money(1599).describe())
}

Quando avviene il boxing

Il wrapper ricompare (boxing) quando il valore viene usato come nullable, come interfaccia o in una raccolta generica. In questi casi il compilatore crea un oggetto reale: il comportamento resta corretto, ma è meno efficiente.

@JvmInline
value class Id(val raw: Int)

fun main() {
    val direct = Id(1)        // inlined
    val boxed: Id? = Id(2)    // boxed because nullable
    println("" + direct.raw + " " + boxed?.raw)
}

value class vs data class

Una data class alloca sempre un oggetto e può contenere molte proprietà. Una value class ne contiene esattamente una e punta a un overhead nullo. Scelga le value class per wrapper sottili e type-safe attorno a un singolo valore.

Perché è importante

Le value class consentono di:

Impedire di confondere parametri dello stesso tipo
Associare la convalida a un tipo primitivo
Non sostenere, solitamente, alcun costo a runtime

Sono la risposta type-safe nei casi in cui gli alias non sono sufficienti.

Verifica rapida

Verifichi la sua comprensione delle inline value class.

Riepilogo

Ha imparato a usare le inline value class:

Dichiarate con @JvmInline value class e una proprietà
Un tipo distinto con overhead solitamente nullo
Supportano metodi, proprietà calcolate e convalida tramite init
Il boxing avviene quando il valore è nullable, generico o usato come interfaccia

Prossimo argomento: casi d'uso reali.

Domande Frequenti

La lezione «Inline value class» è gratuita?

Sì — il testo completo di «Inline value class» è 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 «Inline value class»?

Esegua il wrapping senza overhead 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 2 di 4.

Quanto tempo richiede la lezione «Inline value class»?

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

← Torna a Kotlin Academy