Kotlin 构造函数

2024 年 8 月 29 日 | 4 分钟阅读

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

Kotlin 构造函数的类型

Kotlin 中有两种类型的构造函数

主构造函数
次构造函数

Kotlin 类中只有一个主构造函数，而次构造函数可能有一个或多个。

Kotlin 主构造函数

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

让我们看一个主构造函数声明的例子。在下面的代码中，我们声明一个带有两个参数 name 和 id 的构造函数 myClass。参数 name 是只读属性，而 id 是读写属性。

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 关键字为前缀。在实例初始化期间，初始化的块按照它们在类主体中出现的相同顺序执行。

让我们使用初始化块重写上面的代码

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”。属性 *name* 和 *id* 在没有“val”或“var”的情况下使用，因此它们不是 myClass 类的属性。

当创建 myClass 类的对象时，它执行初始化块，该块初始化 _name 和 e_id。

Kotlin 次构造函数

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

让我们看一个次构造函数声明的例子。在下面的代码中，我们使用两个参数 *name* 和 *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

下一个主题Kotlin 可见性修饰符

← 上一个下一个 →

Kotlin 构造函数