În acest articol, veți afla despre constructorii din Kotlin (atât constructorii primari, cât și cei secundari), precum și despre blocurile de inițializatoare cu ajutorul exemplelor.
Un constructor este un mod concis de a inițializa proprietățile clasei.
Este o funcție specială de membru care se numește atunci când un obiect este instanțiat (creat). Cu toate acestea, modul lor de funcționare în Kotlin este ușor diferit.
În Kotlin, există doi constructori:
- Constructor primar - mod concis de a inițializa o clasă
- Constructor secundar - vă permite să puneți logică de inițializare suplimentară
Constructor primar
Constructorul principal face parte din antetul clasei. Iată un exemplu:
clasa Person (val firstName: String, var age: Int) (// corpul clasei)
Blocul de cod înconjurat de paranteze este constructorul principal: (val firstName: String, var age: Int).
Constructorul a declarat două proprietăți: firstName(proprietate numai în citire așa cum este declarată folosind cuvânt cheie val) și age(proprietate în citire-scriere așa cum este declarată cu cuvânt cheie var).
Exemplu: Constructor primar
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) ( )
Când rulați programul, ieșirea va fi:
Prenume = Joe Age = 25
Când obiectul Personclasei este creat "Joe"și 25valorile sunt transmise ca și cum ar Personfi o funcție.
Aceasta inițializează firstNameși ageproprietățile obiectului person1 "Joe"și 25respectiv.
Există și alte modalități de utilizare a constructorilor primari.
Constructor primar și blocuri de inițializator
Constructorul principal are o sintaxă constrânsă și nu poate conține niciun cod.
Pentru a pune codul de inițializare (nu numai codul pentru inițializarea proprietăților), se utilizează blocul inițializator. Este prefixat cu initcuvânt cheie. Să modificăm exemplul de mai sus cu blocul inițializator:
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") ) )
Când rulați programul, ieșirea va fi:
First Name = Joe Age = 25
Aici, parametrii fName și personAge din paranteză acceptă valori "Joe"și, 25respectiv, atunci când este creat obiectul person1. Cu toate acestea, fName și personAge sunt utilizate fără a utiliza varsau valși nu sunt proprietăți ale Personclasei.
PersonClasa are două proprietăți firstName, și vârsta sunt declarate.
Când person1obiectul este creat, codul din blocul inițializatorului este executat. Blocul de inițializare nu numai că își inițializează proprietățile, ci și le imprimă.
Iată un alt mod de a efectua aceeași sarcină:
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") ) )
Pentru a distinge parametrul și proprietatea constructorului, se folosesc nume diferite (fName și prenume și personAge și age). Este mai frecvent să folosiți _firstName și _age în loc de nume complet diferit pentru parametrii constructorului. De exemplu:
clasa Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // initializer block init (…))
Valoare implicită în constructorul primar
Puteți furniza valoare implicită parametrilor constructorului (similar cu furnizarea argumentelor implicite funcțiilor). De exemplu:
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") ) )
Când rulați programul, ieșirea va fi:
Prenume = Joe Vârsta = 25 de persoane2 este instanțiată Prenume = Jack Vârsta = 0 persoană3 este instanțată Prenume = NECUNOSCUT Vârstă = 0
Kotlin Constructor secundar
În Kotlin, o clasă poate conține, de asemenea, unul sau mai mulți constructori secundari. Acestea sunt create folosind constructorcuvinte cheie.
Constructorii secundari nu sunt atât de obișnuiți în Kotlin. Cea mai obișnuită utilizare a constructorului secundar apare atunci când trebuie să extindeți o clasă care oferă mai mulți constructori care inițializează clasa în moduri diferite. Asigurați-vă că verificați moștenirea Kotlin înainte de a o învăța.
Iată cum puteți crea un constructor secundar în Kotlin:
class Log (constructor (date: String) (// un anumit cod) constructor (date: String, numberOfData: Int) (// un anumit cod))
Aici, Logclasa are doi constructori secundari, dar nici un constructor primar.
Puteți extinde cursul ca:
class Log (constructor (date: String) (// code) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) constructor (date: String, numberOfData: Int): super (data, numberOfData) (// cod))
Aici, constructorii clasei derivate AuthLognumesc constructorul corespunzător al clasei de bază Log. Pentru asta, super()se folosește.
În Kotlin, puteți apela și un constructor dintr-un alt constructor din aceeași clasă (ca în Java) folosind this().
class AuthLog: Log (constructor (date: String): acest (date, 10) (// cod) constructor (date: String, numberOfData: Int): super (data, numberOfData) (// code))
Exemplu: constructor secundar Kotlin
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) ( ) )
Când rulați programul, ieșirea va fi:
Din AuthLog -> Parolă greșită: de 10 ori
Notă: Constructorul secundar trebuie să inițializeze clasa de bază sau să delege altui constructor (ca în exemplul de mai sus) dacă clasa nu are un constructor primar.
