In questo articolo imparerai a conoscere i costruttori in Kotlin (costruttori sia primari che secondari) nonché i blocchi di inizializzazione con l'aiuto di esempi.
Un costruttore è un modo conciso per inizializzare le proprietà della classe.
È una funzione membro speciale che viene chiamata quando un oggetto viene istanziato (creato). Tuttavia, il modo in cui funzionano a Kotlin è leggermente diverso.
In Kotlin, ci sono due costruttori:
- Costruttore primario : modo conciso per inizializzare una classe
- Costruttore secondario : consente di inserire logica di inizializzazione aggiuntiva
Costruttore primario
Il costruttore principale fa parte dell'intestazione della classe. Ecco un esempio:
class Person (val firstName: String, var age: Int) (// class body)
Il blocco di codice circondato da parentesi è il costruttore principale: (val firstName: String, var age: Int).
Il costruttore ha dichiarato due proprietà: firstName(proprietà di sola lettura come dichiarata utilizzando la parola chiave val) e age(proprietà di lettura-scrittura come dichiarata con parola chiave var).
Esempio: costruttore principale
fun main(args: Array) ( val person1 = Person("Joe", 25) println("First Name = $(person1.firstName)") println("Age = $(person1.age)") ) class Person(val firstName: String, var age: Int) ( )
Quando esegui il programma, l'output sarà:
Nome = Joe Età = 25
Quando Personviene creato l'oggetto della classe "Joe"ei 25valori vengono passati come se Personfosse una funzione.
Questo inizializza firstNamee le ageproprietà dell'oggetto person1 a "Joe"e 25rispettivamente.
Esistono altri modi per utilizzare i costruttori primari.
Costruttore primario e blocchi inizializzatore
Il costruttore principale ha una sintassi vincolata e non può contenere codice.
Per inserire il codice di inizializzazione (non solo il codice per inizializzare le proprietà), viene utilizzato il blocco di inizializzazione. È preceduto da una initparola chiave. Modifichiamo l'esempio precedente con il blocco inizializzatore:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName: String var age: Int // initializer block init ( firstName = fName.capitalize() age = personAge println("First Name = $firstName") println("Age = $age") ) )
Quando esegui il programma, l'output sarà:
First Name = Joe Age = 25
Qui, i parametri fName e personAge tra parentesi accettano valori "Joe"e 25rispettivamente quando viene creato l'oggetto person1. Tuttavia, fName e personAge vengono utilizzati senza utilizzare varo vale non sono proprietà della Personclasse.
La Personclasse ha due proprietà firstName e age sono dichiarate.
Quando person1viene creato l'oggetto, viene eseguito il codice all'interno del blocco inizializzatore. Il blocco inizializzatore non solo inizializza le sue proprietà, ma le stampa.
Ecco un altro modo per eseguire la stessa operazione:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName = fName.capitalize() var age = personAge // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Per distinguere il parametro e la proprietà del costruttore, vengono utilizzati nomi diversi (fName e firstName, personAge ed age). È più comune usare _firstName e _age invece di nomi completamente diversi per i parametri del costruttore. Per esempio:
class Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // initializer block init (…))
Valore predefinito nel costruttore principale
È possibile fornire un valore predefinito ai parametri del costruttore (simile a fornire argomenti predefiniti alle funzioni). Per esempio:
fun main(args: Array) ( println("person1 is instantiated") val person1 = Person("joe", 25) println("person2 is instantiated") val person2 = Person("Jack") println("person3 is instantiated") val person3 = Person() ) class Person(_firstName: String = "UNKNOWN", _age: Int = 0) ( val firstName = _firstName.capitalize() var age = _age // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Quando esegui il programma, l'output sarà:
First Name = Joe Age = 25 person2 is instantiated First Name = Jack Age = 0 person3 is instantiated First Name = UNKNOWN Age = 0
Costruttore secondario di Kotlin
In Kotlin, una classe può anche contenere uno o più costruttori secondari. Vengono creati utilizzando la constructorparola chiave.
I costruttori secondari non sono così comuni in Kotlin. L'utilizzo più comune del costruttore secondario si presenta quando è necessario estendere una classe che fornisce più costruttori che inizializzano la classe in modi diversi. Assicurati di controllare Kotlin Inheritance prima di apprenderlo.
Ecco come puoi creare un costruttore secondario in Kotlin:
class Log (constructor (data: String) (// some code) constructor (data: String, numberOfData: Int) (// some code))
In questo caso, la Logclasse ha due costruttori secondari, ma nessun costruttore principale.
Puoi estendere la classe come:
class Log (constructor (data: String) (// code) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) costruttore (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Qui, i costruttori della classe derivata AuthLogchiamano il corrispondente costruttore della classe base Log. Per questo, super()viene utilizzato.
In Kotlin, puoi anche chiamare un costruttore da un altro costruttore della stessa classe (come in Java) usando this().
class AuthLog: Log (constructor (data: String): this (data, 10) (// code) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Esempio: Kotlin Secondary Constructor
fun main(args: Array) ( val p1 = AuthLog("Bad Password") ) open class Log ( var data: String = "" var numberOfData = 0 constructor(_data: String) ( ) constructor(_data: String, _numberOfData: Int) ( data = _data numberOfData = _numberOfData println("$data: $numberOfData times") ) ) class AuthLog: Log ( constructor(_data: String): this("From AuthLog -> " + _data, 10) ( ) constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) ( ) )
Quando esegui il programma, l'output sarà:
Da AuthLog -> Bad Password: 10 volte
Nota: il costruttore secondario deve inizializzare la classe base o delegare a un altro costruttore (come nell'esempio precedente) se la classe non ha un costruttore primario.
