Kotlin Academy · Lezione

Funzioni e classi generiche

Parametrizzi i tipi

Funzioni e classi generiche è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cosa sono i generics?

I generics consentono di scrivere codice che funziona con molti tipi mantenendo la completa sicurezza dei tipi. Invece di fissare un tipo concreto, si usa un parametro di tipo, spesso T, come segnaposto.

Una funzione generica

Una funzione generica dichiara il proprio parametro di tipo tra parentesi angolari prima del nome della funzione. In questo caso T può essere qualsiasi tipo.

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(42))
    println(identity("hello"))
}

Inferenza del tipo

Raramente è necessario specificare esplicitamente il tipo: il compilatore deduce T dagli argomenti. Se necessario, è comunque possibile scrivere identity<Int>(42).

fun <T> firstOf(a: T, b: T): T = a

fun main() {
    val x = firstOf(10, 20)
    val y = firstOf("a", "b")
    println("$x $y")
}

Più parametri di tipo

Una funzione può avere diversi parametri di tipo, una caratteristica utile per lavorare con coppie di tipi non correlati.

fun <A, B> makePair(first: A, second: B): Pair<A, B> {
    return Pair(first, second)
}

fun main() {
    val p = makePair("age", 30)
    println(p)
}

Una classe generica

Anche le classi possono essere generiche. Il parametro di tipo viene dichiarato dopo il nome della classe e può essere usato per proprietà e funzioni.

class Box<T>(val value: T) {
    fun get(): T = value
}

fun main() {
    val intBox = Box(123)
    val strBox = Box("Kotlin")
    println(intBox.get())
    println(strBox.get())
}

Classe generica con comportamento

Le classi generiche possono contenere uno stato mutabile e operare sul parametro di tipo, come un semplice contenitore.

class Stack<T> {
    private val items = mutableListOf<T>()
    fun push(item: T) { items.add(item) }
    fun pop(): T = items.removeAt(items.size - 1)
    fun isEmpty() = items.isEmpty()
}

fun main() {
    val stack = Stack<Int>()
    stack.push(1)
    stack.push(2)
    println(stack.pop())
}

Interfacce generiche

Anche le interfacce possono dichiarare parametri di tipo, lasciando alle implementazioni la scelta del tipo concreto.

interface Container<T> {
    fun item(): T
}

class StringContainer : Container<String> {
    override fun item(): String = "fixed"
}

fun main() {
    println(StringContainer().item())
}

Perché non usare semplicemente Any?

È possibile memorizzare i valori come Any, ma in questo modo si perdono le informazioni sul tipo e sono necessari dei cast. I generics preservano il tipo esatto, consentendo al compilatore di rilevare gli errori senza bisogno di cast.

fun main() {
    val box: Box<String> = Box("text")
    val s: String = box.get()
    println(s.uppercase())
}

class Box<T>(val value: T) { fun get(): T = value }

Funzioni di estensione generiche

Le funzioni di estensione possono essere generiche, consentendo di creare utilità riutilizzabili per tutti i tipi.

fun <T> T.printAndReturn(): T {
    println("Value: $this")
    return this
}

fun main() {
    val x = 5.printAndReturn()
    "hi".printAndReturn()
    println(x)
}

Convenzioni di denominazione

Per convenzione, i parametri di tipo vengono indicati con singole lettere maiuscole: T per un tipo generico, E per un elemento, K e V per chiavi e valori di una mappa, R per un risultato.

I generics sono ovunque

La libreria standard di Kotlin si basa sui generics: List<T>, Map<K, V>, Pair<A, B>. Comprendere i generics aiuta a leggere e usare questi tipi con sicurezza.

Verifica rapida

Qual è il vantaggio principale dei generics rispetto all'uso di Any?

Riepilogo

I generics usano parametri di tipo come T per scrivere funzioni, classi e interfacce riutilizzabili e sicure dal punto di vista dei tipi. Il compilatore deduce i tipi e ne garantisce la sicurezza, evitando i cast. Nel prossimo capitolo imparerà a controllare le relazioni tra i tipi generici usando la varianza sul sito di dichiarazione con in e out.

Domande Frequenti

La lezione «Funzioni e classi generiche» è gratuita?

Sì — il testo completo di «Funzioni e classi generiche» è 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 «Funzioni e classi generiche»?

Parametrizzi i tipi 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 1 di 4.

Quanto tempo richiede la lezione «Funzioni e classi generiche»?

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