每天学一点 Kotlin -- 类的构造函数
----《第一季Kotlin崛起：次世代Android开发 》学习笔记
总目录：每天学一点 Kotlin ---- 目录
上一篇：每天学一点 Kotlin -- 初识类和对象
下一篇：每天学一点 Kotlin -- 类的属性
1. 构造函数
1.1 构造函数是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值。
1.2 在 Kotlin 中一个类可以有一个主构造函数以及一个或多个次构造函数。
2. 主构造函数
2.1 主构造函数是类头的一部分：它跟在类名（与可选的类型参数）后。
第一种写法：
class Friend constructor(val name: String, val age: Int){}
第二种写法：
class Friend constructor（name: String, age: Int）{
val name: String = name
val age: Int = age
}
2.2 如果主构造函数没有任何注解或者可见性修饰符，可以省略 constructor 关键字。写成：
class Friend(name: String, age: Int）{
val name: String = named
val age: Int = age
}
注意：如果主构造函数中有注解或者可见性修饰符，那么 constructor 关键字是不能省略的。比如：
class Friend private constructor(val name: String, val age: Int){}
2.3 和 Java 中的区别： 在 Java 中，Friend(name: String, age: Int）这个构造函数是写在 Friend 类中的，和成员方法是平行的。在 Kotlin 中，这个构造函数是在定义类的开头就写出来的。
2.4 类定义紧跟的大括号里的内容是对这个类的详细声明部分，可以定义属性和方法，定义的属性和方法是不属于构造函数的，主构造函数本身是没有代码的。 ---- 这点很绕人，想不通，个人觉得不是很好，分明就是类的声明么，为啥要称为主构造函数呢，傻逼。。。
3. Init 代码块
3.1 在主构造函数中不能有代码，Kotlin 中提供了初始化代码块，那就是 init。
3.2 在 init 代码块中，可以编写这个对象在实例化构造完成后要执行的语句。
3.3 举个栗子：
fun main() {
var friend = Friend2("xiaoMing", 20)
}
class Friend2(name: String, age: Int) {
init {
println("name: $name , age = $age")
}
var name: String = ""
var age: Int = 0
}
打印结果：
name: xiaoMing , age = 20
可以看到，实例化对象之后，init 会被自动调用，这才跟 Java 中构造函数有一点像了。
4. 次构造函数
4.1 在类定义中，用 constructor 关键字来声明次构造函数。
4.2 按照 Java 中的习惯，我们定义以下类：
class Friend3(name: String, age: Int) {
var name: String = name
var age: Int = age
init {
println("name: $name , age = $age")
}
constructor(name: String, age: Int) {
this.name = name
this.age = age
}
}
但是上面的写法是错误的，编译器会在主构造函数和次构造函数的下面画出红线，那我们把主构造函数的参数删除了， 并且把类中的成员变量重新赋值：
fun main() {
val friend4 = Friend4("xiaoMing", 30)
}
class Friend4 {
var name: String = "null"
var age: Int = 0
init {
println("name: $name , age = $age")
}
// 次构造函数
constructor(name: String, age: Int) {
this.name = name
this.age = age
}
}
打印结果：
name: null , age = 0
4.3 小结：
(1) init 初始化块跟 Java 中静态初始化块很相似。
(2) constructor 声明的次构造函数才跟 Java 中构造函数是相似了。。。
4.4 主构造函数和次构造函数可以共存：前提是每个次构造函数都需要委托给主构造函数。举个栗子1：
fun main() {
var friend5_1 = Friend5("xiaoMing", 51)
var friend5_2 = Friend5("xiaoQiang", 52, friend5_1)
}
class Friend5(name: String, age: Int) {
var friend: Friend5? = null
init {
println("name = ${name}, age = ${age}")
}
constructor(name: String, age: Int, friend: Friend5) : this(name, age) {
friend.friend = this
}
}
打印结果：
name = xiaoMing, age = 51
name = xiaoQiang, age = 52
举个栗子2：
fun main() {
val baby1 = Person("baby1", 3)
val baby2 = Person("baby2", 4)
val parent1 = Person("parent1", 40)
val parent2 = Person("parent2", 50)
val child1 = Person("child1", 20, mutableListOf(parent1, parent2), mutableListOf(baby1, baby2))
baby1.showPersonInfo()
parent1.showPersonInfo()
parent1.showChildrenInfo()
child1.showPersonInfo()
child1.showChildrenInfo()
child1.showParentInfo()
}
class Person(name: String, age: Int) {
val name: String = name
val age: Int = age
var parents = mutableListOf<Person>()
var children = mutableListOf<Person>()
// 次构造函数
constructor(name: String, age: Int, parents: MutableList<Person>, children: MutableList<Person>) : this(name, age) {
parents.forEach { it.children.add(this) }
children.forEach { it.parents.add(this) }
this.parents.addAll(parents)
this.children.addAll(children)
}
fun showPersonInfo() = println("name = ${this.name}, age = ${this.age}")
fun showChildrenInfo() = children.forEach { it.showPersonInfo() }
fun showParentInfo() = parents.forEach { it.showPersonInfo() }
}
打印结果：
name = baby1, age = 3
name = parent1, age = 40
name = child1, age = 20
name = child1, age = 20
name = baby1, age = 3
name = baby2, age = 4
name = parent1, age = 40
name = parent2, age = 50
5. 默认构造函数
5.1 当我们没有任何主构造函数和次构造函数的时候，Kotlin 会给我们自动生成一个默认的主构造函数，也就是没有任何构造参数。
5.2 在之前的内容里面，下面这一句就使用的是默认构造函数：
val friend = Friend()
