W tym artykule dowiesz się o konstruktorach w Kotlinie (zarówno konstruktorach podstawowych, jak i pomocniczych), a także o blokach inicjalizujących za pomocą przykładów.
Konstruktor to zwięzły sposób inicjowania właściwości klas.
Jest to specjalna funkcja składowa wywoływana podczas tworzenia instancji obiektu (tworzenia). Jednak sposób ich pracy w Kotlinie jest nieco inny.
W Kotlinie są dwaj konstruktorzy:
- Konstruktor podstawowy - zwięzły sposób na zainicjowanie klasy
- Konstruktor pomocniczy - pozwala na umieszczenie dodatkowej logiki inicjalizacyjnej
Podstawowy konstruktor
Główny konstruktor jest częścią nagłówka klasy. Oto przykład:
class Osoba (val firstName: String, var wiek: Int) (// treść klasy)
Podstawowym konstruktorem jest blok kodu otoczony nawiasami (val firstName: String, var age: Int).
Konstruktor zadeklarował dwie właściwości: firstName(właściwość tylko do odczytu, która została zadeklarowana przy użyciu słowa kluczowego val) i age(właściwość do odczytu i zapisu, zgodnie z deklaracją za pomocą słowa kluczowego var).
Przykład: główny konstruktor
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) ( )
Po uruchomieniu programu wynik będzie następujący:
Imię = Joe Age = 25
Kiedy Persontworzony jest obiekt klasy, "Joe"a 25wartości są przekazywane tak, jakby Personbyły funkcją.
To inicjalizuje firstNamei agewłaściwości obiektu person1 odpowiednio do "Joe"i 25.
Istnieją inne sposoby korzystania z konstruktorów podstawowych.
Podstawowy konstruktor i bloki inicjatora
Podstawowy konstruktor ma ograniczoną składnię i nie może zawierać żadnego kodu.
Aby umieścić kod inicjujący (nie tylko kod inicjujący właściwości), używany jest blok inicjujący. Jest poprzedzony initsłowem kluczowym. Zmodyfikujmy powyższy przykład blokiem inicjalizatora:
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") ) )
Po uruchomieniu programu wynik będzie następujący:
First Name = Joe Age = 25
Tutaj parametry fName i personAge w nawiasach przyjmują wartości "Joe"i 25odpowiednio, kiedy tworzony jest obiekt person1 . Jednak fName i personAge są używane bez użycia varlub vali nie są właściwościami Personklasy.
PersonKlasa ma dwie właściwości imię, wiek i zostały zadeklarowane.
Po person1utworzeniu obiektu wykonywany jest kod wewnątrz bloku inicjalizatora. Blok inicjalizatora nie tylko inicjuje swoje właściwości, ale także je drukuje.
Oto inny sposób wykonania tego samego zadania:
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") ) )
Aby odróżnić parametr i właściwość konstruktora, używane są różne nazwy (fName i firstName oraz personAge i age). Częściej używa się _firstName i _age zamiast zupełnie innych nazw parametrów konstruktora. Na przykład:
class Osoba (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var wiek = _age // inicjalizator blok init (…))
Wartość domyślna w głównym konstruktorze
Możesz podać wartość domyślną dla parametrów konstruktora (podobnie do dostarczania domyślnych argumentów do funkcji). Na przykład:
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") ) )
Po uruchomieniu programu wynik będzie następujący:
First Name = Joe Age = 25 utworzono instancję person2 First Name = Jack Age = 0 utworzono instancję person3 First Name = UNKNOWN Age = 0
Konstruktor pomocniczy Kotlin
W Kotlinie klasa może również zawierać jeden lub więcej konstruktorów pomocniczych. Tworzone są za pomocą constructorsłowa kluczowego.
Drugorzędni konstruktorzy nie są tak powszechni w Kotlinie. Najczęstsze użycie konstruktora pomocniczego pojawia się, gdy trzeba rozszerzyć klasę, która udostępnia wiele konstruktorów, które inicjują klasę na różne sposoby. Pamiętaj, aby sprawdzić Dziedziczenie Kotlin, zanim się tego nauczysz.
Oto jak możesz utworzyć pomocniczego konstruktora w Kotlinie:
class Log (constructor (data: String) (// jakiś kod) constructor (data: String, numberOfData: Int) (// jakiś kod))
Tutaj Logklasa ma dwa konstruktory pomocnicze, ale nie ma konstruktora podstawowego.
Możesz rozszerzyć klasę jako:
class Log (constructor (data: String) (// code) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) konstruktor (dane: String, numberOfData: Int): super (data, numberOfData) (// kod))
Tutaj konstruktory klasy pochodnej AuthLogwywołują odpowiedni konstruktor klasy bazowej Log. Do tego super()służy.
W Kotlinie możesz również wywołać konstruktor z innego konstruktora tej samej klasy (jak w Javie) za pomocą this().
class AuthLog: Log (constructor (data: String): this (data, 10) (// code) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// kod))
Przykład: konstruktor pomocniczy 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) ( ) )
Po uruchomieniu programu wynik będzie następujący:
Z AuthLog -> Złe hasło: 10 razy
Uwaga: Konstruktor pomocniczy musi zainicjować klasę bazową lub delegować do innego konstruktora (jak w powyższym przykładzie), jeśli klasa nie ma konstruktora podstawowego.
