Kotlin 构造函数（Constructor）

在本文中，您将在示例的帮助下了解Kotlin中的构造函数（主要构造函数和次构造函数）以及初始化程序块。

构造函数是初始化类属性的简洁方法。

它是一个特殊的成员函数，在实例化（创建）对象时调用。但是，它们在Kotlin中的工作方式略有不同。

在Kotlin中，有两个构造函数：

• 主构造函数 - 初始化类的简洁方法

• 次构造函数 - 允许您放置其他初始化逻辑

主构造函数

主构造函数是类标头的一部分。这是一个实例：

class Person(val firstName: String, var age: Int) {
　　　　// class body
}

用括号括起来的代码块是主要的构造函数：(val firstName: String, var age: Int)。

构造函数声明了两个属性：firstName（只读属性，因为它是使用关键字val声明的）和age（读写属性，因为它是用关键字var声明的）。

示例：主构造函数

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

Quando si esegue il programma, l'output è:

First Name = Joe
Age = 25

当创建 Person 类的对象时，将传递值 Joe 和 25，就好像Person是一个函数一样。

这将 person1 对象的 firstName 和 age 属性分别初始化为 "Joe" 和 25。

还有其他使用主要构造函数的方法。

主构造函数和初始化语句块

主构造函数的语法受约束，不能包含任何代码。

为了放置初始化代码（不仅是初始化属性的代码），使用了初始化程序块。它以 init 关键字为前缀 。让我们用初始化语句块修改以上示例：

fun main(args: Array<String>) {
　　　　val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName: String
　　　　var age: Int
　　　　// blocco di inizializzazione
　　　　init {
　　　　　　　　firstName = fName.capitalize()
　　　　　　　　age = personAge
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age")
　　　　}
}

Quando si esegue il programma, l'output è:

First Name = Joe
Age = 25

Qui, durante la creazione dell'oggetto person1, i parametri tra parentesi graffe fName e personAge accettano i valori "Joe" e 25. Tuttavia, quando si utilizza fName e personAge, non si utilizza var o val, e non sono attributi della classe Person.

La classe Person dichiara due proprietà firstName e age.

Quando l'oggetto person1 viene creato, il codice all'interno del blocco di inizializzazione viene eseguito. Il blocco di inizializzazione non solo inizializza le proprietà, ma anche stampa le uscite.

Questo è un altro metodo per eseguire la stessa attività:

fun main(args: Array<String>) {
　　　　val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
　　　　val firstName = fName.capitalize()
　　　　var age = personAge
　　　　// blocco di inizializzazione
　　　　init {
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age")
　　　　}
}

Per distinguere i parametri del costruttore dagli attributi, sono stati utilizzati nomi diversi (fName e FirstName, nonché Personage e age). Per i parametri del costruttore, è più comune utilizzare _firstName e _age, piuttosto che nomi completamente diversi. Ad esempio:

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

Valori predefiniti nel costruttore principale

Puoi fornire valori predefiniti ai parametri del costruttore (similmente a come fai per le funzioni)Parametri predefiniti）。Ad esempio：

fun main(args: Array<String>) {
　　　　println("person1 è stato istanzionato")
　　　　val person1 = Person("joe", 25)
　　　　println("person2 è stato istanzionato")
　　　　val person2 = Person("Jack")
　　　　println("person3 è stato istanzionato")
　　　　val person3 = Person()
}
class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　// blocco di inizializzazione
　　　　init {
　　　　　　　　println("First Name = $firstName")
　　　　　　　　println("Age = $age\n")
　　　　}
}

Quando si esegue il programma, l'output è:

First Name = Joe
Age = 25
person2 è stato istanzionato
First Name = Jack
Age = 0
person3 è istanziata
First Name = UNKNOWN
Age = 0

Costruttore secondario in Kotlin

In Kotlin, una classe può anche avere uno o più costruttori secondari. Questi vengono creati utilizzando la parola chiave constructor.

I costruttori secondari in Kotlin non sono così comuni. La loro utilizzazione più comune si verifica quando si ha bisogno di estendere una classe che fornisce più costruttori per inizializzare la classe in modi diversi. Prima di imparare, assicurati di aver già capitoEreditarietà Kotlin.

Puoi creare un costruttore secondario in Kotlin nel modo seguente:

class Log {
　　　　constructor(data: String) {
　　　　　　　　// Alcuni codici
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　// Alcuni codici
　　　　}
}

In questo caso, la classe Log ha due costruttori secondari ma non un costruttore principale.

Puoi estendere la classe come segue:

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

In questo caso, il costruttore del sottoclasse AuthLog chiama il costruttore corrispondente della classe base Log. Per fare questo, si utilizza super().

In Kotlin, puoi anche usare this() per chiamare un costruttore di un'altra classe dello stesso tipo (come in Java).

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

Esempio: Costruttore secondario in Kotlin

fun main(args: Array<String>) {
　　　　val p1 = AuthLog("Password Sbagliato")
}
open class Log {
　　　　var data: String = ""
　　　　var numberOfData = 0
　　　　constructor(_data: String) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int) {
　　　　　　　　data = _data
　　　　　　　　numberOfData = _numberOfData
　　　　　　　　stampa("$data: $numberOfData volte")
　　　　}
}
class AuthLog: Log {
　　　　constructor(_data: String): this("Da AuthLog -> " + _data, 10) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

Quando si esegue il programma, l'output è:

Da AuthLog -> Password errata: 10 volte

Attenzione:Se la classe non ha un costruttore principale, il costruttore secondario deve inizializzare la superclasse o il delegato come un altro costruttore (come nell'esempio sopra).