Kotlin-Konstruktor (Constructor)

In diesem Artikel werden Sie unter Verwendung von Beispielen die Konstruktoren (Hauptkonstruktor und Nebenkonstruktor) und Initialisierungsblöcke in Kotlin kennenlernen.

Der Konstruktor ist ein kompakter Weg zur Initialisierung der Klasseeigenschaften.

Es ist eine spezielle Memberfunktion, die bei der Instanziierung (Erstellung) eines Objekts aufgerufen wird. Aber ihre Arbeitsweise in Kotlin ist etwas unterschiedlich.

In Kotlin gibt es zwei Konstruktoren:

• Hauptkonstruktor - Kompakter Weg zur Initialisierung der Klasse

• Nebenkonstruktor - ermöglicht es Ihnen, andere Initialisierungslogik zu platzieren

Hauptkonstruktor

Der Hauptkonstruktor ist ein Teil der Klassekopf. Hier ist ein Beispiel:

class Person(val firstName: String, var age: Int) {
　　　　//　Klassenkörper
}

Der Codeblock in Klammern ist der Hauptkonstruktor: (val firstName: String, var age: Int).

Der Konstruktor deklariert zwei Eigenschaften: firstName (lesbare Eigenschaft, da sie mit dem Schlüsselwort val deklariert wird) und age (schreibbare Eigenschaft, da sie mit dem Schlüsselwort var deklariert wird).

Beispiel: Hauptkonstruktor

fun main(args: Array<String>) {
　　　　val person1　= Person("Joe",　25)
　　　　println("Vorname = ${person1.firstName}")
　　　　println("Alter = ${person1.age})
}
class Person(val firstName: String, var age: Int) {
}

Wenn das Programm ausgeführt wird, lautet die Ausgabe:

Vorname = Joe
Alter =　25

Wenn ein Objekt der Klasse Person erstellt wird, werden die Werte Joe und 25so, als wäre Person eine Funktion.

Das wird person1 Die Eigenschaften firstName und age des Objekts werden initialisiert mit "Joe" und 25.

Es gibt auch andere Methoden zur Verwendung des Hauptkonstruktors.

Hauptkonstruktor und Initialisierungsblock

Die Syntax des Hauptkonstruktors ist eingeschränkt und kann keine Codezeilen enthalten.

Um Initialisierungscode (nicht nur Initialisierungscode für Eigenschaften) zu platzieren, wurde ein Initialisierungsblock verwendet. Er beginnt mit dem Präfix init. Lassen Sie uns den Beispielcode mit einem Initialisierungsanweisungsblock ändern:

fun main(args: Array<String>) {
　　　　val person1　= Person("joe",　25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: String
　　　　var age: Int
　　　　//Initialisierungsblock
　　　　init {
　　　　　　　　firstName: fName.capitalize()
　　　　　　　　age: personAge
　　　　　　　　println("Vorname = $firstName")
　　　　　　　　println("Alter = $age")
　　　　}
}

Wenn das Programm ausgeführt wird, lautet die Ausgabe:

Vorname = Joe
Alter =　25

hier, beim Erstellen von person1erstellt wird, werden die Werte "Joe" und 25。但是，当使用 fName 和 personAge 时, nicht var oder val verwenden, und sie sind keine Eigenschaften der Klasse Person.

Die Klasse Person声明了两个属性 firstName und age.

wenn person1Das Objekt wird erstellt, und der Code im Initialisierungsblock wird ausgeführt. Der Initialisierungsblock initialisiert nicht nur seine Eigenschaften, sondern gibt sie auch aus.

Dies ist eine andere Methode, um die gleiche Aufgabe zu erledigen:

fun main(args: Array<String>) {
　　　　val person1　= Person("joe",　25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: fName.capitalize()
　　　　var age: personAge
　　　　//Initialisierungsblock
　　　　init {
　　　　　　　　println("Vorname = $firstName")
　　　　　　　　println("Alter = $age")
　　　　}
}

Um Konstruktorparameter und Eigenschaften zu unterscheiden, werden verschiedene Namen verwendet (fName und FirstName, sowie Personage und age). Für Konstruktorparameter ist es häufiger, _firstName und _age zu verwenden, anstatt vollständig unterschiedliche Namen. Zum Beispiel:

class Person(_firstName: String, _age: Int) {
　　　　val firstName: _firstName.capitalize()
　　　　var age: _age
　　　　//　Initialisierungsblock
　　　　init {
　　　　　　　　...　..　...
　　　　}
}

Standardwerte im Hauptkonstruktor

Sie können Standardwerte für Konstruktorparameter angeben (ähnlich wie fürStandardparameter）。例如：

fun main(args: Array<String>) {
　　　　println("person1　wird instanziert")
　　　　val person1　= Person("joe",　25)
　　　　println("person2　wird instanziert")
　　　　val person2　= Person("Jack")
　　　　println("person3　wird instanziert")
　　　　val person3　= Person()
}
class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
　　　　val firstName: _firstName.capitalize()
　　　　var age: _age
　　　　//Initialisierungsblock
　　　　init {
　　　　　　　　println("Vorname = $firstName")
　　　　　　　　println("Alter = $age\n")
　　　　}
}

Wenn das Programm ausgeführt wird, lautet die Ausgabe:

Vorname = Joe
Alter =　25
person2　wird instanziert
Vorname = Jack
Alter = 0
person3　wird instanziert
Vorname = UNKNOWN
Alter = 0

Kotlin-Nachkonstruktor

Eine Klasse kann in Kotlin auch eine oder mehrere Nachkonstruktoren enthalten. Sie werden mit dem Schlüsselwort constructor erstellt.

Nachkonstruktoren sind in Kotlin nicht so häufig. Der häufigste Gebrauch von Nachkonstruktoren tritt auf, wenn Sie eine Klasse erweitern müssen, die mehrere Konstruktoren mit verschiedenen Initialisierungsmethoden bereitstellt. Bevor Sie lernen, stellen Sie sicher, dass Sie bereitsKotlin Vererbung.

Sie können in Kotlin Methoden zur Erstellung von Nachkonstruktoren wie folgt erstellen:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Einige Codezeilen
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Einige Codezeilen
　　　　}
}

Hier hat die Klasse Log zwei Nachkonstruktoren, aber keinen Hauptkonstruktor.

Sie können die Klasse erweitern, indem Sie:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Code
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Code
　　　　}
}
class AuthLog: Log {
　　　　constructor(data: String): super(data) {
　　　　　　　　//　Code
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Code
　　　　}
}

Hier ruft der Konstruktor der Ableitung AuthLog den entsprechenden Konstruktor der Basisklasse Log auf. Dafür wird super() verwendet.

In Kotlin können Sie auch this() verwenden, um einen Konstruktor aus einer anderen Konstruktorfunktion desselben Typs (wie in Java) aufzurufen.

class AuthLog: Log {
　　　　constructor(data: String): this(data,　10) {
　　　　　　　　//　Code
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Code
　　　　}
}

Beispiel: Kotlin-Nachkonstruktor

fun main(args: Array<String>) {
　　　　val p1　= AuthLog("Schlechter Passwort")
}
open class Log {
　　　　var data: String = ""
　　　　var numberOfData = 0
　　　　constructor(_data: String) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int) {
　　　　　　　　data = _data
　　　　　　　　numberOfData = _numberOfData
　　　　　　　　println("$data: $numberOfData mal")
　　　　}
}
class AuthLog: Log {
　　　　constructor(_data: String): this("From AuthLog　-> "　+　_data,　10) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

Wenn das Programm ausgeführt wird, lautet die Ausgabe:

From AuthLog　-Bad Password:　10　times

Hinweis:Wenn eine Klasse keinen Hauptkonstruktor hat, muss die Sekundärkonstruktorfunktion die Basisklasse oder Delegation initialisieren, indem sie eine andere Konstruktorfunktion initialisiert (wie im obigen Beispiel gezeigt).