一. 嵌套类

只要将一个类放在另一个类中定义，这个类就变成了嵌套类，相当于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->{} //强制要求你将每一个子类所对应的条件全部处理,如果不进行处理编译器就会进行报错提醒
}

kotlin学习总结之八类和对象2

kotlin学习总结之八类和对象2

一. 嵌套类

二. 内部类

三. 匿名内部类

三. 伴生对象 Companion Objects

四. 数据类

五. 密封类

定义

使用场景

kotlin学习总结之八 类和对象2

一. 嵌套类

二. 内部类

三. 匿名内部类

三. 伴生对象 Companion Objects

四. 数据类

五. 密封类

定义

使用场景

kotlin学习总结之八类和对象2