----《第一季Kotlin崛起：次世代Android开发 》学习笔记
总目录：每天学一点 Kotlin ---- 目录
上一篇：每天学一点 Kotlin -- 多彩的类：泛型
下一篇：每天学一点 Kotlin -- 多彩的类：枚举类
1. 嵌套类
1.1 类似于 Java 中的内部类。 Kotlin 中也可以在类内部再申明一个类。举个栗子：
class Big {
var name: String = "big_name"
val size: Int = 20
fun showInfo() {
println("Big() -- name = $name, size = $size")
}
class Small {
val size: Int = 10
val addr: String = "small_addr"
fun showMsg() {
// println("Small() -- name = $name, size = $size") // 编译报错
println("Small() -- addr = $addr, size = $size")
}
}
}
fun testBig() {
val big = Big()
val small = Big.Small()
big.showInfo()
small.showMsg()
println("name = ${big.name}")
println("size = ${big.size}")
// println("addr = ${big.addr}") // 编译报错
println("addr = ${small.addr}")
println("size = ${small.size}")
// println("name = ${small.name}") // 编译报错, 是正确的，因为 Small() 类里面没有这个属性，而且也没有继承 Big() 类
}
打印结果：
Big() -- name = big_name, size = 20
Small() -- addr = small_addr, size = 10
name = big_name
size = 20
addr = small_addr
size = 10
1.2 上面的代码中，内部类的申明及使用和普通的类没啥区别。但是和 Java 中不同的是：Java 中成员内部类可以无条件访问外部类的所有成员属性和成员方法，而在 Kotlin 中内部类无法访问外部类中的属性。在 Kotlin 中如果要实现访问的话，就需要通过关键字 inner 标记嵌套类。
2. inner 关键字：
2.1 上面的代码中，如果通过内部类对象来访问外部类的属性则编译器直接会报错，提示不存在。那么是不是就没有办法访问了呢？其实是可以的，那就是用关键字 inner 标记嵌套类，这时也称为内部类。内部类带有一个对外部类的引用。修改后的代码如下：
class Big1 {
var name: String = "big_name"
val size: Int = 20
fun showInfo() {
println("Big1() -- name = $name, size = $size")
}
inner class Small {
val size: Int = 10
val addr: String = "small_addr"
fun showMsg() {
println("Small1() -- name = $name, size = $size") // 编译通过
println("Small1() -- addr = $addr, size = $size")
}
}
}
fun testBig1() {
val big = Big1()
val small = Big1().Small() // 创建对象时：通过 Big1 的对象 创建 Small 的对象
big.showInfo()
small.showMsg()
println("testBig1() -- name = ${big.name}")
println("testBig1() -- size = ${big.size}")
// println("addr = ${big.addr}") // 编译报错
println("testBig1() -- addr = ${small.addr}")
println("testBig1() -- size = ${small.size}")
// println("name = ${small.name}") // 编译报错, 是正确的，因为 Small() 类里面没有这个属性，而且也没有继承 Big() 类
}
fun main(args: Array<String>) {
testBig1()
}
打印结果：
Big1() -- name = big_name, size = 20
Small1() -- name = big_name, size = 10
Small1() -- addr = small_addr, size = 10
testBig1() -- name = big_name
testBig1() -- size = 20
testBig1() -- addr = small_addr
testBig1() -- size = 10
2.2 和 1.1 中的代码相比，有以下几点不同：
(1) 内部类 Small 前面加了关键字： inner
(2) 在内部类 Small 中直接访问外部的属性也没有问题
(3) 在创建内部类 Small 的对象时，是通过外部类的对象来创建的。所以这行代码会有两次括号val small = Big1().Small()。
3. this 和 this@label
3.1 在 2.1 的代码中还有一个问题：外部类和内部类的属性设置的是同一个变量(size)，从打印结果看，嵌套类中引用时，嵌套类貌似"覆盖"了外部类的属性，怎么在使用中区分这两个属性呢？
3.2 可以使用关键 this 和 this@label 来解决上述问题：
(1) “this” 表示当前类的对象
(2) this@label 可以访问外部类，lable 是指 this 来源的标签，比如类名。
3.3 举个栗子：
class Big2 {
var name: String = "big_name"
val size: Int = 20
fun getSizeInBig2_1() {
println("getSizeInBig1 --- size = " + size)
}
fun getSizeInBig2_2() {
println("getSizeInBig2 --- size = " + this.size)
}
fun getSizeInBig2_3() {
println("getSizeInBig3 --- size = " + this@Big2.size)
}
fun getSizeInBig2_4() {
// println("getSizeInBig4 --- size = " + this@Small.size) // 编译报错
}
inner class Small {
val size: Int = 10
val addr: String = "small_addr"
fun printInSmall() {
println("name = $name, addr = " + addr)
}
fun getSizeInSmall_1() {
println("getSizeInSmall1() --- size = " + size)
}
fun getSizeInSmall_2() {
println("getSizeInSmall2() --- size = " + this.size)
}
fun getSizeInSmall_3() {
println("getSizeInSmall3() --- size = " + this@Big2.size)
}
fun getSizeInSmall_4() {
println("getSizeInSmall4() --- size = " + this@Small.size)
}
}
}
fun testBig2() {
val big = Big2()
val small = Big2().Small()
println("in big")
big.getSizeInBig2_1()
big.getSizeInBig2_2()
big.getSizeInBig2_3()
println("in small")
small.printInSmall()
small.getSizeInSmall_1()
small.getSizeInSmall_2()
small.getSizeInSmall_3()
small.getSizeInSmall_4()
}
fun main(args: Array<String>) {
testBig2()
}
打印结果：
in big
getSizeInBig1 --- size = 20
getSizeInBig2 --- size = 20
getSizeInBig3 --- size = 20
in small
name = big_name, addr = small_addr
getSizeInSmall1() --- size = 10
getSizeInSmall2() --- size = 10
getSizeInSmall3() --- size = 20
getSizeInSmall4() --- size = 10
3.4 继承和嵌套类的区别：
(1) 从声明上看，继承的父子两个类单独声明。而内部类必须声明在外部类里面，并且用关键字 inner 标识；
(2) 从访问上看，继承时，父类不能直接访问子类。使用嵌套类时，外部类可以通过"外部类().内部类()"的形式访问内部类；继承时，子类能直接访问父类公开的属性和方法；而使用嵌套类时，内部类需要通过"this@lable" 的方式访问外部类的属性和方法；
(3) 从覆盖看，继承时，子类能覆盖父类公开的属性或方法。内部类不能覆盖外部类的属性或方法；
(4) 从定义对象看，继承时，子类定义方式为：var/val son = Son()。内部类的定义方式为：val/var inter = Outer().Inter()。
