kotlin修炼指南6-Sealed到底密封了啥
在代码中，我们经常需要限定一些有限集合的状态值，例如：
- 网络请求：成功——失败
- 账户状态：VIP——穷逼VIP——普通
- 工具栏：展开——半折叠——收缩
等等。
通常情况下，我们会使用enum class来做封装，将可见的状态值通过枚举来使用。
enum class NetworkState(val value: Int) {
SUCCESS(0),
ERROR(1)
}
但枚举的缺点也很明显，首先，枚举比普通代码更占内存，同时，每个枚举只能定义一个实例，不能拓展更多信息。
除此之外，还有种方式，通过抽象类来对状态进行封装，但这种方式的缺点也很明显，它打破了枚举的限制性，所以，Kotlin给出了新的解决方案——Sealed Class（密封类）。
创建状态集
下面我们以网络请求的例子来看下具体如何使用Sealed Class来进行状态的封装。
和抽象类类似，Sealed Class可用于表示层级关系。它的子类可以是任意的类：data class、普通Kotlin对象、普通的类，甚至也可以是另一个密封类，所以，我们定义一个Result Sealed Class：
sealed class Result<out T : Any> {
data class Success<out T : Any>(val data: T) : Result<T>()
data class Error(val exception: Exception) : Result<Nothing>()
}
当然，也不一定非要写在顶层类中：
sealed class Result<out T : Any>
data class Success<out T : Any>(val data: T) : Result<T>()
data class Error(val exception: Exception) : Result<Nothing>()
这样也是可以的，它们的区别在于引用的时候，是否包含顶层类来引用而已。
大部分场景下，还是建议第一种方式，可以比较清晰的展示调用的层级关系。
在这个例子中，我们定义了两个场景，分别是Success和Error，它表示我们假设的网络状态就这两种，分别在每种状态下，例如Success，都可以传入自定义的数据类型，因为它本身就是一个class，所以借助这一点，就可以自定义状态携带的场景值。在上面这个例子中，我们定义在Success中，传递data，而在Error时，传递Exception信息。
所以，使用Sealed Class的第一步，就是对场景进行封装，梳理具体的场景枚举，并定义需要传递的数据类型。
如果场景值不需要传递数据，那么可以简单的使用：object xxxx，定义一个变量即可。
使用
接下来，我们来看下如何使用Sealed Class。
fun main() {
// 模拟封装枚举的产生
val result = if (true) {
Result.Success("Success")
} else {
Result.Error(Exception("error"))
}
when (result) {
is Result.Success -> print(result.data)
is Result.Error -> print(result.exception)
}
}
大部分场景下，Sealed Class都会配合when一起使用，同时，如果when的参数是Sealed Class，在IDE中可以快速补全所有分支，而且不会需要你单独补充else 分支，因为Sealed Class已经是完备的了。
所以when和Sealed Class真是天作之合。
进一步简化
其实我们还可以进一步简化代码的调用，因为我们每次使用Sealed Class的时候，都需要when一下，有些时候，也会产生一些代码冗余，所以，借助拓展函数，我们进一步对代码进行简化。
inline fun Result<Any>.doSuccess(success: (Any) -> Unit) {
if (this is Result.Success) {
success(data)
}
}
inline fun Result<Any>.doError(error: (Exception?) -> Unit) {
if (this is Result.Error) {
error(exception)
}
}
这里我对Result进行了拓展，增加了doSuccess和doError两个拓展，同时接收两个高阶函数来接收处理行为，这样我们在调用的时候就更加简单了。
result.doSuccess { }
result.doError { }
所以when和Sealed Class和拓展函数，真是天作之合。
那么你一定好奇了，Sealed Class又是怎么实现的，其实反编译一下就一目了然了，实际上Sealed Class也是通过抽象类来实现的，编译器生成了一个只能编译器调用的构造函数，从而避免其它类进行修改，实现了Sealed Class的有限性。
封装？
Sealed Class与抽象类类似，可以对逻辑进行拓展，我们来看下面这个例子。
sealed class TTS {
abstract fun speak()
class BaiduTTS(val value: String) : TTS() {
override fun speak() = print(value)
}
class TencentTTS(val value: String) : TTS() {
override fun speak() = print(value)
}
}
这时候如果要进行拓展，就很方便了，代码如下所示。
class XunFeiTTS(val value: String) : TTS() {
override fun speak() = print(value)
}
所以，Sealed Class可以说是在抽象类的基础上，增加了对状态有限性的控制，拓展与抽象，比枚举更加灵活和方便了。
再例如前面网络的封装：
sealed class Result<out T : Any> {
data class Success<out T : Any>(val data: T) : Result<T>()
sealed class Error(val exception: Exception) : Result<Nothing>() {
class RecoverableError(exception: Exception) : Error(exception)
class NonRecoverableError(exception: Exception) : Error(exception)
}
object InProgress : Result<Nothing>()
}
通过Sealed Class可以很方便的对Error类型进行拓展，同时，增加新的状态也非常简单，更重要的是，通过IDE的自动补全功能，IDE可以自动生成各个条件分支，避免人工编码的遗漏。
