一. 嵌套类

只要将一个类放在另一个类中定义，这个类就变成了嵌套类，相当于Java中static修饰的静态内部类。

class Outer {                  // 外部类
    private val value: Int = 1

    class Nested {             // 嵌套类
        var inValue = 2
        fun nestedMethod() {
            // println(value)       //嵌套类无法直接访问外部类属性
            println(Outer().value) //但可以通过外部类的对象访问，因为有private修饰符，普通类通过对象也无法访问
        }
    }

    fun outerMethod() {
        // println(inValue)         //外部类无法直接访问嵌套类的属性
        // method()                 //外部类无法直接访问嵌套类的方法
        println(Nested().inValue) //外部类无法通过嵌套类的对象访问private属性，但是可以访问public
    }
}

fun main() {
    val demo = Outer.Nested().inValue // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

二. 内部类

部类是一种特殊的嵌套类，被嵌套到里面的类使用inner关键字修饰，内部类可以拥有对外部类的引用。但是外部类没有内部类的引用。所以内部类可以访问外部类成员属性和成员函数。
特点

• 内部类成员可以直接访问外部类的私有数据，因为内部类相当于外部类的成员之一。
• 外部类不能访问内部类的成员，如需访问，需要通过创建内部类对象，通过对象访问内部类成员。

class Outer {
    private val value1: Int = 1
    var value2 = "成员属性"

    /**嵌套内部类**/
    inner class Inner {
        fun innerFun() = value1  // 访问外部类成员
        fun innerTest() {
            val outer = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，bar：${innerFun()}")
            println("内部类可以引用外部类的成员，例如：${outer.value2}")
        }
    }
}


fun main(args: Array<String>) {
    val demo = Outer().Inner().innerFun()
    println(demo) //   1
    Outer().Inner().innerTest()
}

为了消除歧义，要访问来自外部作用域的 this，我们使用this@label，其中 @label是一个 代指 this 来源的标签。

• 为什么内部类可以调用外部类私有成员？
  ​在内部类对象中，保存了一个该内部类所寄生的外部类的对象的引用。
  内部类在方法中访问属性顺序：方法是否有该变量（如果没有，下同）=》内部类是否有该属性=》外部类是否有该属性，如果都没有，则编译报错。

• 为什么外部类不能直接调用内部类成员？
  ​创建外部类对象时，内部类根本还不存在，因此也不存在直接使用该对象内部类的成员了。

三. 匿名内部类

名内部类主要是针对那些获取抽象类或者接口对象而来的。最常见的匿名内部类点击事件：

interface OnClickListener {
    fun onClick()
}

class View {
    fun setClickListener(clickListener: OnClickListener) {

    }
}

fun main(args: Array<String>) {
    val view = View()
    view.setClickListener(object : OnClickListener {
        override fun onClick() {

        }
    })
}

三. 伴生对象 Companion Objects

与Java不同的是，在kotlin中，类是没有显式的static方法和static成员变量的。大多数情况下，推荐顶层函数。但是顶层函数不能访问类的private成员，因此需要通过伴生对象的形式间接提供的。

Kotlin语言中使用"companion object"修饰静态方法，可以使用类名.方法名的形式调用，如下：

class Util {
    companion object {
        fun getCurrentVersion(): String {
            return BuildConfig.VERSION_NAME
        }
    }
}

调用：

var version_name2 = Util .getCurrentVersion()

四. 数据类

在类的声明前添加data关键字，即可将一个类定义成数据类。

data class <类名> <(主构造函数参数列表)> [:继承类和实现接口] [(/*类体*/)]

主构造函数的参数列表必须使用val或var声明为类属性，而且要求 至少有一个，否则无法通过编译。

data class User(val id:Int, val name:String)

数据类功能:

• 自动声明与构造函数入参同名的属性字段。
• 自动实现每个属性字段的存取器方法set/get。
• 自动提供equals方法用于比较两个数据对象是否相等。
• 自动提供copy方法允许完整复制某个数据对象。
• 自动提供toString方法。

五. 密封类

定义

就像我们为什么要用enum类型一样，我们经常需要在代码中声明一些有限集合，如: 网络请求可能为成功或失败需要先定义一个enum类型 网络请求状态NetStatus，再定义Loading、Success、Error这些网络请求状态。枚举就是为了控制住你所有要的情况是正确的，而不是用硬编码方式写成字符串“Loading”，“Success”，“Error”。
同样的，密封类（sealed）的目的类似，一个类之所以设计成sealed，就是为了限制类的继承结构，将一个值限制在有限集中的类型中，而不能有任何其他的类型。

密封类用来表示受限的类继承结构（规定了有限个类型，不可以存在其他类型）。是一种同时拥有枚举类 enum 和 普通类 class 特性的类。可以保证我们写出更安全的代码。

密封类与枚举类 :
① 相同点 ( 类型限制 ) : 从类型种类角度对比 , 类与枚举类类似 , 枚举类的值的集合是受限制的 , 不能随意扩展 ;
② 不同点 ( 对象个数限制 ) : 从每个类型对象个数对比 , 枚举类的每个类型只能存在一个实例 (每一个枚举值代表一个类的实例), 而密封类的每个类型可以创建无数个实例 ;

所以可以将密封类看做是枚举的拓展，基于枚举，高于枚举。枚举类型的每个值只允许有一个实例，同时枚举也无法为每个类型添加额外信息，例如，您无法为枚举中的 "Error" 添加相关的 Exception 类型数据。而且不能控制对象的构建时机，当枚举类构建时 NetStatus 中的各种子类也必须构建好。

虽然也可以使用一个抽象类然后让一些类继承它，这样就可以随意扩展，但这会失去枚举所带来的有限集合的优势。也可以说成，密封类是包含了一组受限的类集合，因为里面的类都是继承自这个密封类的。但是其和其他继承类（open）的区别在，密封类可以不被此文件外被继承，有效保护代码。所以说密封类 则同时包含了前面两者的优势 —— 抽象类表示的灵活性和枚举里集合的受限性。

因为是抽象类，所以不能实例化，只能实例化其子类。更多的在于限制继承，起到划分子类的作用，规定了有限个类型，不可以存在其他任何类型（即子类是确定的，不存在子类以外的类型）。

使用场景

• 禁止外部继承，对于一些只划分固定类型的数据，保证安全（作用类似于枚举）。

• when遍历密封类的子类时，不用加else语句。(主要解决了when结构需要添加一个默认的else分支的问题)
  例如：
  新建一个 Result.kt

interface NetworkStatus
class Loading : NetworkStatus()
class Successed : NetworkStatus()

fun getResultMsg(result: NetworkStatus) = when(result) {
    is Loading -> {}
    is Successed -> {}
    else -> throw IllegalArgumentException()
}

这里定义了一个 NetworkStatus 接口，然后定义了两个类去实现 NetworkStatus 接口。然后再写一个 getResultMsg() 方法。实际上 Result 的执行结果只能是 Loading 或 Successed，所以里边的 else 永远无法走到，但我们不得不写上，只是为了满足 Kotlin 编译器的语法检查而已。
密封类可以帮我们解决这个问题：

sealed class NetworkStatus
class Loading : NetworkStatus()
class Successed : NetworkStatus()

fun getResultMsg(result: NetworkStatus) = when(result) {
    is Loading -> {}
    is Successed -> {}
}

• 如果添加了一个新的分支，编译器无法发现有的地方发生了改变。如果忘记了添加这个新的分支，就会选择默认选项，所以有隐藏bug。
  例如:

sealed class NetworkStatus
class Loading : NetworkStatus()
class Successed : NetworkStatus()
class Error(val code: Int, val message: String) : NetworkStatus()

fun getResultMsg(result: NetworkStatus) = when(result) {
    is Loading -> {}
    is Successed -> {}
    is Error->{} //强制要求你将每一个子类所对应的条件全部处理,如果不进行处理编译器就会进行报错提醒
}