0Pricing
Kotlin Academy · Lezione

Funzioni di estensione: sintassi e regole di dispatch

Scriva funzioni di estensione e comprenda la semantica del dispatch statico.

Funzioni di estensione: sintassi e regole di dispatch è 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 le funzioni di estensione

Le funzioni di estensione consentono di aggiungere nuove funzioni a classi esistenti senza modificarle o utilizzare l'ereditarietà.

Sintassi di base delle funzioni di estensione

Anteponi al nome della funzione il tipo che si sta estendendo, chiamato «tipo ricevitore».
fun String.shout(): String = uppercase() + "!"
println("hello".shout())  // HELLO!
fun Int.isEven() = this % 2 == 0
println(4.isEven())  // true

this nelle estensioni

All'interno di una funzione di estensione, «this» fa riferimento all'oggetto ricevitore.
fun List<Int>.secondOrNull(): Int? {
    return if (size >= 2) this[1] else null
}
println(listOf(10, 20, 30).secondOrNull())  // 20
println(listOf(5).secondOrNull())           // null

Dispatch statico: le estensioni non eseguono l'override

Le funzioni di estensione vengono risolte staticamente in fase di compilazione in base al tipo dichiarato: NON sono virtuali.
open class Base
class Child : Base()
fun Base.greet() = "Hello from Base"
fun Child.greet() = "Hello from Child"

val obj: Base = Child()
println(obj.greet())  // "Hello from Base" (static dispatch!)

Estensioni e funzioni membro

Se una classe dispone di una funzione membro con la stessa firma di un'estensione, prevale sempre la funzione membro.
class Greeter {
    fun hello() = "member hello"
}
fun Greeter.hello() = "extension hello"  // shadowed!
println(Greeter().hello())  // "member hello"

Estensioni con ricevitore nullable

È possibile estendere i tipi nullable. All'interno, gestisca il valore null con controlli «this == null».
fun String?.orEmpty() = this ?: ""
fun Any?.toStringSafe() = this?.toString() ?: "null"
println(null.orEmpty())  // ""
println(42.toStringSafe())  // "42"

Visibilità e ambito

Le estensioni possono essere di primo livello (globali), trovarsi in una classe (estensioni membro) o in un file. Seguono le normali regole di visibilità.
// Top-level extension:
fun List<String>.joinUppercase() = joinToString { it.uppercase() }
// Private to file:
private fun String.clean() = trim().lowercase()

Estensioni dell'oggetto companion

Aggiunga estensioni a un companion object per estendere il namespace a livello di classe.
class User(val name: String) {
    companion object
}
fun User.Companion.guest() = User("Guest")
val guest = User.guest()

Estensioni dei tipi della libreria standard

È possibile estendere qualsiasi tipo, inclusi i tipi predefiniti.
fun Double.roundTo(decimals: Int): Double {
    val factor = Math.pow(10.0, decimals.toDouble())
    return Math.round(this * factor) / factor
}
println(3.14159.roundTo(2))  // 3.14

Organizzazione delle estensioni

Raggruppi le estensioni di un tipo in un file dedicato, ad esempio StringExtensions.kt o DateExtensions.kt.
// StringExtensions.kt
fun String.titleCase() = split(" ")
    .joinToString(" ") {
        it.replaceFirstChar { c -> c.uppercase() }
    }
println("hello world".titleCase())  // Hello World

Le estensioni non possono accedere ai membri private

Le estensioni hanno accesso solo ai membri public e internal, non a quelli private o protected.
class Secret {
    private val key = "hidden"
    val name = "public"
}
fun Secret.reveal() {
    println(name)  // OK
    // println(key)  // Error: key is private
}

Verifica rapida

Se una funzione membro di una classe e una funzione di estensione hanno la stessa firma, quale viene chiamata?

Riepilogo

Le funzioni di estensione aggiungono comportamento a qualsiasi classe senza modificarla. Il dispatch è statico (non è possibile fare l'override). I membri prevalgono sulle estensioni. Utilizzi ricevitori nullable per creare helper sicuri rispetto a null. Prossimo argomento: proprietà di estensione

Domande Frequenti

La lezione «Funzioni di estensione: sintassi e regole di dispatch» è gratuita?

Sì — il testo completo di «Funzioni di estensione: sintassi e regole di dispatch» è 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 di estensione: sintassi e regole di dispatch»?

Scriva funzioni di estensione e comprenda la semantica del dispatch statico. 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 di estensione: sintassi e regole di dispatch»?

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

  1. Funzioni di estensione: sintassi e regole di dispatch
  2. Proprietà di estensione ed estensioni calcolate
  3. Estensioni con ambito ed estensioni del companion
  4. Estensioni pratiche: helper per Context, View e String
← Torna a Kotlin Academy