Costruttore primario e parametri delle proprietà
Dichiari classi con costruttori primari e dichiarazioni inline delle proprietà.
Costruttore primario e parametri delle proprietà è 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.
Il costruttore primario
Una classe Kotlin dichiara il proprio costruttore primario subito dopo il nome della classe, tra parentesi. Non serve un corpo di metodo: è sufficiente un elenco di parametri.
La classe più semplice
Il costruttore primario senza modificatori non è visibile dopo il nome della classe.
class Greeter(val name: String) {
fun greet() = "Hello, $name!"
}
fun main() {
println(Greeter("Ada").greet())
}Parametri come proprietà
Anteponendo val o var a un parametro del costruttore, lo si trasforma in una proprietà della classe in un solo passaggio.
class Person(val name: String, var age: Int)
fun main() {
val p = Person("Bob", 30)
println("${p.name} is ${p.age}")
p.age = 31
println("Now ${p.age}")
}Parametri senza val/var
I parametri del costruttore senza val/var sono locali al costruttore: possono essere utilizzati nei blocchi init o negli inizializzatori delle proprietà, ma non sono accessibili in seguito.
class Logger(prefix: String) {
val msg = "$prefix: ready"
}
fun main() {
val l = Logger("[INFO]")
println(l.msg)
// l.prefix // ERROR — not a property
}Valori predefiniti dei parametri
Fornisca valori predefiniti per i parametri del costruttore, così da evitare il codice ripetitivo degli overload.
class User(
val name: String,
val age: Int = 0,
val email: String = ""
)
fun main() {
println(User("Ana").age) // 0
println(User("Ben", 25).email) // ""
println(User("Cal", 30, "c@x.io").email)
}Argomenti con nome
Ignori l'ordine posizionale e assegni un nome ai parametri nel punto della chiamata, soprattutto quando sono presenti valori predefiniti.
class HttpClient(
val baseUrl: String,
val timeoutMs: Int = 5000,
val retries: Int = 3
)
fun main() {
val c = HttpClient(
baseUrl = "https://api.example.com",
retries = 5
)
println("retries=${c.retries} timeout=${c.timeoutMs}")
}Visibilità del costruttore
Utilizzi private constructor per impedire l'istanziazione dall'esterno: è una scelta comune insieme ai metodi factory.
class Singleton private constructor() {
companion object {
val instance = Singleton()
}
}
fun main() {
val s = Singleton.instance
println(s)
}Costruttori secondari
Aggiunga altri costruttori con la parola chiave constructor. Devono delegare al costruttore primario tramite this(...).
class Point(val x: Int, val y: Int) {
constructor(value: Int) : this(value, value)
}
fun main() {
println("${Point(3).x}, ${Point(3).y}") // 3, 3
}Costruttore con visibilità
È possibile specificare una visibilità diversa per ciascun costruttore, una soluzione utile nelle librerie.
class Lib internal constructor(val key: String) {
companion object {
fun create(key: String) = Lib(key)
}
}
fun main() {
println(Lib.create("abc").key)
}Riepilogo del blocco init
Il codice che deve essere eseguito durante la costruzione va inserito in un blocco init { }. Più blocchi init vengono eseguiti nell'ordine in cui compaiono nel codice sorgente.
class Validator(val value: String) {
init { require(value.isNotBlank()) { "value cannot be blank" } }
}
fun main() {
println(Validator("ok").value)
// Validator("") // throws IllegalArgumentException
}Combinazione di proprietà e logica
Le dichiarazioni di proprietà, i costruttori secondari e i blocchi init si combinano in una pipeline di inizializzazione flessibile.
class Account(
val owner: String,
initialBalance: Double = 0.0
) {
var balance: Double = initialBalance
private set
init {
require(initialBalance >= 0) { "balance must be non-negative" }
}
fun deposit(amount: Double) { balance += amount }
}
fun main() {
val a = Account("Alice", 100.0)
a.deposit(50.0)
println("${a.owner}: ${a.balance}") // Alice: 150.0
}Verifica rapida
Che cosa fa la parola chiave val quando viene utilizzata in un parametro del costruttore primario?
Riepilogo
Il costruttore primario si trova nell'intestazione della classe. Utilizzi val/var per trasformare i parametri in proprietà; i parametri senza modificatori restano locali al costruttore. Aggiunga valori predefiniti per ridurre gli overload ed esegua la logica di configurazione nei blocchi init. I costruttori secondari delegano tramite this(...).
Domande Frequenti
La lezione «Costruttore primario e parametri delle proprietà» è gratuita?
Sì — il testo completo di «Costruttore primario e parametri delle proprietà» è 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 «Costruttore primario e parametri delle proprietà»?
Dichiari classi con costruttori primari e dichiarazioni inline delle proprietà. 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 «Costruttore primario e parametri delle proprietà»?
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
- Costruttore primario e parametri delle proprietà
- Blocchi init e ordine di inizializzazione
- Getter e setter personalizzati con field
- lateinit e inizializzazione lazy