Kotlin Academy · Lezione

Vincoli dei generics

Limiti i parametri di tipo

Vincoli dei generics è 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.

Vincolo dei parametri di tipo

A volte un generic deve accettare solo determinati tipi, ad esempio tipi confrontabili o sottoclassi di una classe base. I vincoli dei generics impostano un limite superiore per un parametro di tipo.

Il limite superiore predefinito

In assenza di un vincolo, il limite superiore di un parametro di tipo è Any?, quindi accetta qualsiasi tipo, inclusi quelli nullable. Per consentire solo tipi non nullable, lo vincoli a Any.

fun <T : Any> requireNonNull(value: T): T {
    return value
}

fun main() {
    println(requireNonNull(42))
}

Un singolo limite superiore

Utilizzi T : Bound per richiedere che T sia un sottotipo di Bound. In questo modo può chiamare i membri del limite all'interno della funzione.

fun <T : Number> sumDoubled(a: T, b: T): Double {
    return a.toDouble() * 2 + b.toDouble() * 2
}

fun main() {
    println(sumDoubled(3, 4))
    println(sumDoubled(1.5, 2.5))
}

Limite Comparable

Un limite comune è Comparable<T>, che consente di confrontare gli elementi con <, > o compareTo.

fun <T : Comparable<T>> maxOf2(a: T, b: T): T {
    return if (a > b) a else b
}

fun main() {
    println(maxOf2(3, 9))
    println(maxOf2("apple", "banana"))
}

Chiamata dei membri del limite

All'interno di un generic vincolato, il compilatore sa che T dispone dell'API del limite, quindi può chiamare direttamente questi metodi senza eseguire conversioni di tipo.

fun <T : CharSequence> describe(value: T): String {
    return "Length is ${value.length}"
}

fun main() {
    println(describe("hello"))
    println(describe(StringBuilder("hi")))
}

Più limiti con where

Per specificare più di un limite, utilizzi la clausola where. T deve quindi soddisfare TUTTI i vincoli elencati.

fun <T> copyWhenValid(value: T): T
    where T : CharSequence, T : Comparable<T> {
    return value
}

fun main() {
    println(copyWhenValid("text"))
}

Limiti nelle classi

I vincoli funzionano anche sulle classi generiche e limitano i tipi con cui è possibile istanziare la classe.

class NumberBox<T : Number>(val value: T) {
    fun asDouble(): Double = value.toDouble()
}

fun main() {
    val box = NumberBox(10)
    println(box.asDouble())
}

Il vincolo abilita le operazioni

Lo scopo principale di un vincolo è abilitare determinate operazioni. Senza T : Number non potrebbe chiamare toDouble(); il limite garantisce che il metodo esista.

Il limite non nullable nella pratica

Vincolare a Any rifiuta gli argomenti nullable in fase di compilazione: è un modo pratico per richiedere generic non nullable.

fun <T : Any> firstNonNull(a: T, b: T): T = a

fun main() {
    println(firstNonNull("x", "y"))
    // firstNonNull(null, "y") would not compile
}

Combinazione con la varianza

Vincoli e varianza risolvono problemi diversi: la varianza (in/out) controlla le relazioni di sottotipizzazione, mentre i vincoli (limiti con : e where) limitano i tipi consentiti. È possibile utilizzarli insieme.

Progettazione di buoni vincoli

Aggiunga un vincolo solo quando ha bisogno di una capacità offerta dal tipo. Vincolare eccessivamente riduce la riusabilità, mentre vincolare troppo poco obbliga a eseguire conversioni di tipo. Utilizzi come limite il tipo più generale che fornisce le operazioni necessarie.

Verifica rapida

Come si richiede che un parametro di tipo soddisfi più di un limite?

Riepilogo

I vincoli dei generics impostano limiti superiori con T : Bound o con where per più limiti, abilitando le operazioni del limite ed escludendo i tipi incompatibili. Vincolare a Any richiede un tipo non nullable. In combinazione con la varianza, i vincoli consentono di progettare generics sicuri ed espressivi. Questo completa il corso Generics e varianza.

Domande Frequenti

La lezione «Vincoli dei generics» è gratuita?

Sì — il testo completo di «Vincoli dei generics» è 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 «Vincoli dei generics»?

Limiti i parametri di tipo 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 «Vincoli dei generics»?

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