0Pricing
Kotlin Academy · Lezione

Dichiarazione object: singleton in Kotlin

Crei singleton con object e ne comprenda il ciclo di vita.

Dichiarazione object: singleton in Kotlin è 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.

object come singleton

Una dichiarazione object crea una singola istanza, un singleton thread-safe inizializzato in modo differito, con una sola riga di codice.

Dichiarare un singleton

Usi object Name { ... } per dichiarare un singleton con stato e metodi.

object Logger {
    fun log(msg: String) = println("[LOG] $msg")
}
fun main() {
    Logger.log("App started")
    Logger.log("User signed in")
}

Stato del singleton

I singleton possono contenere stato mutabile, accessibile da qualsiasi punto e condiviso globalmente.

object Counter {
    var count = 0
    fun increment() { count++ }
}
fun main() {
    Counter.increment()
    Counter.increment()
    Counter.increment()
    println(Counter.count) // 3
}

Inizializzazione differita

La singola istanza viene creata al primo accesso, mai prima. La JVM garantisce che l'operazione sia thread-safe.

object Heavy {
    init { println("Initializing Heavy...") }
    fun work() = "done"
}
fun main() {
    println("Before access")
    println(Heavy.work()) // triggers init now
    println(Heavy.work()) // no init again
}

Implementare interfacce

I singleton possono implementare interfacce, una caratteristica utile per callback e strategie.

interface Greeter { fun greet(name: String): String }
object EnglishGreeter : Greeter {
    override fun greet(name: String) = "Hello, $name!"
}
fun main() {
    println(EnglishGreeter.greet("Ada"))
}

Estendere una classe

Gli object possono ereditare anche da classi open.

open class Animal(val sound: String) {
    fun makeSound() = "The animal says $sound"
}
object Cat : Animal("Meow")
fun main() {
    println(Cat.makeSound())
}

Pratica: configurazione

I singleton sono ideali per la configurazione a livello di applicazione che non cambia dopo l'avvio.

object AppConfig {
    val apiUrl = "https://api.example.com"
    val timeout = 5000
    val version = "1.0.0"
}
fun main() {
    println("v${AppConfig.version} -> ${AppConfig.apiUrl}")
}

Pratica: funzioni di utilità

Raggruppi gli helper senza stato in un object, come metodi simili a quelli statici organizzati in uno spazio dei nomi.

object StringUtils {
    fun reverse(s: String) = s.reversed()
    fun capitalize(s: String) = s.replaceFirstChar { it.uppercase() }
}
fun main() {
    println(StringUtils.reverse("Kotlin"))
    println(StringUtils.capitalize("hello"))
}

Uguaglianza e identità

Esiste una sola istanza, quindi === restituisce sempre true per lo stesso riferimento all'oggetto.

object MySingleton
fun main() {
    val a = MySingleton
    val b = MySingleton
    println(a === b) // true
}

object vs class

Una class normale richiede un'istanza. Un object è l'istanza stessa: non viene invocato alcun costruttore.

class Service { fun ping() = "pong (class)" }
object SingletonService { fun ping() = "pong (object)" }
fun main() {
    val s = Service() // instance per call
    println(s.ping())
    println(SingletonService.ping()) // no instantiation
}

Sicurezza dei thread

La creazione dell'istanza singleton è thread-safe grazie alle garanzie del caricamento delle classi della JVM. La gestione dello stato mutabile aggiunto al suo interno è invece una Sua responsabilità.

object SharedCounter {
    @Volatile var count = 0
    @Synchronized fun inc() { count++ }
}
fun main() {
    repeat(1000) { SharedCounter.inc() }
    println(SharedCounter.count) // 1000
}

Verifica rapida

Quante istanze esistono di una dichiarazione Kotlin object?

Riepilogo

object Name { ... } dichiara un singleton lazy thread-safe con stato, metodi, interfacce ed ereditarietà. Usi gli object per configurazioni, gruppi di funzioni di utilità e servizi senza stato.

Domande Frequenti

La lezione «Dichiarazione object: singleton in Kotlin» è gratuita?

Sì — il testo completo di «Dichiarazione object: singleton in Kotlin» è 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 «Dichiarazione object: singleton in Kotlin»?

Crei singleton con object e ne comprenda il ciclo di vita. 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 «Dichiarazione object: singleton in Kotlin»?

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. Dichiarazione object: singleton in Kotlin
  2. companion object: membri simili agli static in Kotlin
  3. Oggetti anonimi ed espressioni object
  4. Metodi factory con companion object
← Torna a Kotlin Academy