Kotlin构造函数

本文概述

• Kotlin主要构造函数
• Kotlin二级构造函数
• 从同一类的另一个辅助构造函数调用一个辅助构造函数
• 从派生类辅助构造函数调用超级类辅助构造函数

在Kotlin中, 构造函数是类似于方法的代码块。构造函数以与类相同的名称声明, 后跟括号“()”。构造函数用于在创建对象时初始化变量。

Kotlin构造函数的类型

Kotlin中有两种构造函数：

1. 主要构造函数
2. 二级构造器

Kotlin类中只有一个主要构造函数, 而次要构造函数可以是一个或多个。

Kotlin主要构造函数

主构造函数用于初始化类。它在类头声明。主构造函数代码用带有可选参数的括号括起来。

让我们看一下主要构造函数的声明示例。在下面的代码中, 我们声明一个带有两个参数名称和id的构造函数myClass。参数名称仅是read属性, 而id是read和write属性。

class myClass(valname: String, varid: Int) {
    // class body
}

创建myClasss的对象时, 它将分别使用“ Ashu”和“ 101”初始化name和id。

class myClass(val name: String, var id: Int) {
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101)

println("Name = ${ myclass.name}")
println("Id = ${ myclass.id}")
}

输出：

Name = Ashu
Id = 101

具有初始化程序块的主要构造函数

主构造函数不包含任何代码。初始化程序块用于代码的初始化。该块的前缀为init关键字。在实例初始化期间, 已初始化的块将按照它们在类主体中出现的顺序执行。

让我们使用initialize块重写以上代码：

class myClass(name: String, id: Int) {
val e_name: String
var e_id: Int
init{
e_name = name.capitalize()
e_id = id

println("Name = ${e_name}")
println("Id = ${e_id}")
    }
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101)

}

输出：

Name = Ashu
Id = 101

在上面的代码中, 创建myclass对象时, 参数name和id接受值“ Ashu”和“ 101”。属性名和ID的使用不带“ val”或“ var”, 因此它们不是myClass类的属性。

创建myClass类的对象时, 它将执行初始化se_name和e_id的初始化程序块。

Kotlin二级构造函数

在Kotlin中, 可以在类中创建一个或多个辅助构造函数。使用“ constructor”关键字创建辅助构造函数。

让我们看一下辅助构造函数的声明示例。在下面的代码中, 我们声明了带有两个参数名称和id的myClass的两个构造函数。

class myClass{

    constructor(id: Int){
        //code 
    }
    constructor(name: String, id: Int){
        //code 
    }
}

让我们看一个示例, 该示例在创建类的对象时为二级构造函数分配值。

class myClass{

    constructor(name: String, id: Int){
println("Name = ${name}")
println("Id = ${id}")
    }
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101)

}

输出：

Name = Ashu
Id = 101

我们还可以在同一类中同时使用主构造函数和辅助构造函数。通过在同一类中同时使用主构造函数和辅助构造函数, 辅助构造函数需要授权给主构造函数。使用this()关键字对同一类中的另一个构造函数进行授权。

例如：

class myClass(password: String){

    constructor(name: String, id: Int, password: String): this(password){
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${password}")
    }
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101, "mypassword")

}

输出：

Name = Ashu
Id = 101
Password = mypassword

从同一类的另一个辅助构造函数调用一个辅助构造函数

在Kotlin中, 一个二级构造函数可以调用同一类的另一个二级构造函数。这是通过使用this()关键字完成的。

例如：

class myClass{

    constructor(name: String, id: Int): this(name, id, "mypassword"){
println("this executes next")
println("Name = ${name}")
println("Id = ${id}")
    }

    constructor(name: String, id: Int, pass: String){
println("this executes first")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
    }
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101)

}

输出：

this executes first
Name = Ashu
Id = 101
Password = mypassword
this executes next
Name = Ashu
Id = 101

从派生类辅助构造函数调用超级类辅助构造函数

在Kotlin中, 一个派生类的辅助构造函数可以调用基类的辅助构造函数。这是使用super关键字完成的, 这是继承的概念。

open class Parent{

    constructor(name: String, id: Int){
println("this executes first")
println("Name = ${name}")
println("Id = ${id}")
    }

    constructor(name: String, id: Int, pass: String){
println("this executes third")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
    }
}
class Child: Parent{
    constructor(name: String, id: Int): super(name, id){
println("this executes second")
println("Name = ${name}")
println("Id = ${id}")
    }

   constructor(name: String, id: Int, pass: String):super(name, id, "password"){
println("this executes forth")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
    }
}
fun main(args: Array<String>){
val obj1 = Child("Ashu", 101)
val obj2 = Child("Ashu", 101, "mypassword")
}

输出：

this executes first
Name = Ashu
Id = 101
this executes second
Name = Ashu
Id = 101
this executes third
Name = Ashu
Id = 101
Password = password
this executes forth
Name = Ashu
Id = 101
Password = mypassword