----《第一季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()。

相关代码：https://gitee.com/fzq.com/test-demo