kotlin入门潜修之类和对象篇—密封类及其原理

本文收录于 kotlin入门潜修专题系列，欢迎学习交流。

创作不易，如有转载，还请备注。

写在前面

三年不翅，将以长羽翼；不飞不鸣，将以观民则。虽无飞，飞必冲天；虽无鸣，鸣必惊人。——与君共勉。

密封类

密封类是kotlin的又一特性，这个概念对于我们来说是陌生的。不过没关系，实际上还是比较容易理解。下面来看下什么是密封类。

密封类首先是类，只不过这些类是有一定限制的类，这里所谓的限制会在下文中阐述，先看下密封类的定义。

kotlin定义密封类的关键字是sealed，如下所示：

sealed class SealedClass//与普通类的区别是增加了sealed关键字

密封类是可以有子类的，但是所有的子类必须和密封类定义在同一个文件中（kotlin1.1之前，更加严格，只能允许定义在密封类的内部），子类定义如下所示：

sealed class SealedClass{
    class SubClass3() : SealedClass()//如果你使用的是kotlin1.1之前的版本，则子类必须要定义在SealedClass中
}
data class SubClass(val num: Int) : SealedClass()//kotlin1.1之后已经放松了限制，可以在外部定义。data类支持继承也是从kotlin1.1版本开始
class SubClass2() : SealedClass()

上面演示了私密类子类的定义，唯一需要注意的就是kotlin1.1之前和之后的定义是不同的，1.1版本之后放松了子类定义位置的限制，在代码注释中已经进行了说明。

此外，补充说明一下：数据类的继承在kotlin1.1版本之前也是不支持的，在kotlin1.1才开始支持数据类的继承，这里所说的继承不单单指继承于私密类，当然也包括继承于普通类。

接着看下面一个例子：

abstract sealed class SealedClass {
}

上面将私密类定义为了abstract，这是合法的，但是你会发现编译器会给出一个警告：

Modifier 'abstract' is redundant because 'sealed' is present

这句话意思是说使用abstract修饰密封类是多余的，密封类本身就是抽象的。因此我们可以直接省略掉abstract，如下所示：

 sealed class SealedClass {
    abstract fun test()//理论上abstract方法所在的类必须要定义为abstract，但是因为密封类本身就是抽象的，所以这里不必显示定义
}

再来看一个例子，如下所示：

sealed class SealedClass public constructor(){//!!编译错误，密封类只允许私有构造方法
}

上面代码清晰的表明密封类是不支持public的构造方法的，无论是主构造方法还是第二构造方法，都必须是private的。密封类默认其构造方法就是private。

前面说到密封类的子类必须要定义在和密封类相同的文件内，那么其子类的子类是不是也必须要定义在文件内部呢？看下面一个例子：

//我们在Test.kt文件中定义了密封类及其子类
sealed class SealedClass {
}
open class SubClass : SealedClass()//注意这里定义为了open，表示可以继承。同时也表明密封类的子类默认并像SealedClass是abstract 的。
//我们在Test2.kt文件中定义了其子类的子类
class SubSubClass : SubClass() {//正确，允许子类的子类写在另一个文件中
}

class SubClass2 : SealedClass()//错误，密封类的直接子类只能和密封类定义到同一个文件中

上面的代码表明，密封类的子类的子类是可以定义在和密封类不同的文件中的。

密封类的用处

上面说了这么多都是在解释密封类的语法知识，并没有说密封类的使用场景是什么，也没有解释密封类是有什么限制的类，本章节就来谈一谈这些问题。

密封类的限制是指，密封类的类型只能是位于其子类集合中的类型，而不能是其他类型。这话怎么讲，看个例子就明白了：

//定义了一个密封类
sealed class SealedClass {
    class SubClass : SealedClass()//密封类的子类SubClass
}
class SubClass1 : SealedClass()//密封类的子类SubClass1
class SubClass2 : SealedClass()//密封类的子类SubClass2

class OtherClass {}//定义了一个的普通类
//测试类
fun test(classType: SealedClass): String = when (classType) {
    is SealedClass.SubClass -> "SubClass"//正确，SubClass属于密封类SealedClass类型
    is SubClass1 -> "SubClass1"//正确，同上
    is SubClass2 -> "SubClass2"//正确，同上
    is OtherClass -> "OtherClass"//错误，OtherClass并不属于密封类SealedClass类型
}

上面代码既说明了密封类的限制，同时也演示了密封类的使用。从代码可以看出，密封类实际上表示了有限的集合类型（即上面定义的密封类的子类型如SubClass1、SubClass2），没有定义在该集合中的类型（即不是密封类的子类，如OtherClass）都不属于该密封类类型。

最后再总结下密封类: 密封类实际上定义了一个特定的集合，这集合中的元素只能是密封类类型(密封类的子类)，不能是其他类型。

密封类和枚举类

通过上面的分析可知，密封类是有限的类型结合，而枚举类也是有限的类型结合，那么二者有什么区别呢？

先来看下枚举类的定义：

enum class Color {//定义了一个枚举类
    RED,//枚举类中的类型
    GREEN
}

了解枚举类的定义后，我们来对比下密封类和枚举类的使用，如下所示：

fun test() {
    val color: Color = Color.GREEN
    val color1: Color = Color.GREEN
    println(color === color1)//打印'true'

    val classType: SealedClass = SubClass2()
    val classType1: SealedClass = SubClass2()
    println(classType == classType1)//打印'false'
}

从上面代码可以很容易看出枚举类和密封类的区别，即枚举类一个类型只能有一个实例，而密封类一个类型则可以有多个实例。

密封类的实现原理

密封类其实没有特别神奇的地方，下面我们就通过字节码来揭露其神秘面纱：

//定义了一个密封类
sealed class SealedClass {
}

其字节码如下所示：

//其底层字节码就是个抽象类
public abstract class com/juandou/mediapikcer/SealedClass {
  // access flags 0x2
  private <init>()V//构造方法，被定义为了private
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lcom/juandou/mediapikcer/SealedClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  @Lkotlin/Metadata;(mv={1, 1, 13}, bv={1, 0, 3}, k=1, d1={"\u0000\u000c\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\u0008\u0002\u00086\u0018\u00002\u00020\u0001B\u0007\u0008\u0002\u00a2\u0006\u0002\u0010\u0002\u00a8\u0006\u0003"}, d2={"Lcom/juandou/mediapikcer/SealedClass;", "", "()V", "app_debug"})
  // compiled from: Test.kt
}

再次强调，字节码文件没有什么很神秘的，我们只需要了解关键地方即可。下面我们来分析下。

由上面字节码可以看出，kotlin中的密封类SealedClass被定义为了public abstract方法，这就是为什么我们没有必要在SealedClass前加abstract修饰符的原因，因为编译器为我们自动加上了。

接着我们看下其构造方法，其字节码的定义如下

  private <init>()V

由此可知，kotlin中的密封类其构造方法实际上被添加了private修饰符，因此是私有的。

在java中我们知道，父类构造方法如果是私有的，那么子类是无法继承的，所以kotlin的密封类无法被外部的类继承。但是从上面代码中可以看出，与密封类处于同一个文件的类显然是可以继承密封类的，这是为什么？

让我们增加一个密封类的子类，如下所示：

sealed class SealedClass {
}
//增加一个私密类的子类
class SubClass1 : SealedClass()

然后我们再来看看其生成的字节码：

public abstract class com/juandou/mediapikcer/SealedClass {
  // access flags 0x2
  private <init>()V
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lcom/juandou/mediapikcer/SealedClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
  // access flags 0x1001
  public synthetic <init>(Lkotlin/jvm/internal/DefaultConstructorMarker;)V//注意这里新增加了一个构造方法，而且是public的
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL com/juandou/mediapikcer/SealedClass.<init> ()V//注意，这里调用了密封类的私有构造方法
    RETURN
   L1
    LOCALVARIABLE this Lcom/juandou/mediapikcer/SealedClass; L0 L1 0
    LOCALVARIABLE $constructor_marker Lkotlin/jvm/internal/DefaultConstructorMarker; L0 L1 1
    MAXSTACK = 1
    MAXLOCALS = 2

  @Lkotlin/Metadata;(mv={1, 1, 13}, bv={1, 0, 3}, k=1, d1={"\u0000\u0010\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0000\n\u0002\u0018\u0002\n\u0000\u00086\u0018\u00002\u00020\u0001B\u0007\u0008\u0002\u00a2\u0006\u0002\u0010\u0002\u0082\u0001\u0001\u0003\u00a8\u0006\u0004"}, d2={"Lcom/juandou/mediapikcer/SealedClass;", "", "()V", "Lcom/juandou/mediapikcer/SubClass1;", "app_debug"})
  // compiled from: Test.kt
}

看到上面字节码后，我们发现，相对于没有子类的密封类，竟然又多出了一个public的构造方法，如下所示：

public synthetic <init>(Lkotlin/jvm/internal/DefaultConstructorMarker;)V

在该构造方法中调用了私有构造方法。即下面的字节码片段：

INVOKESPECIAL com/juandou/mediapikcer/SealedClass.<init> ()V

到这里就恍然大悟了，原来是kotlin为我们定义了一个公有的构造方法，子类一定是通过该公有的构造方法进行初始化的！

到底是不是我们推测的这样呢？很简单，直接看下子类相关的字节码就可明白：

public final class com/juandou/mediapikcer/SubClass1 extends com/juandou/mediapikcer/SealedClass  {
  // access flags 0x1
  public <init>()V//子类的构造方法是public的
   L0
    LINENUMBER 6 L0
    ALOAD 0
    ACONST_NULL
   L1
    LINENUMBER 6 L1
    INVOKESPECIAL com/juandou/mediapikcer/SealedClass.<init> (Lkotlin/jvm/internal/DefaultConstructorMarker;)V//注意这里！！，显然调用了上面kotlin为我们生成的公有方法
    RETURN
   L2
    LOCALVARIABLE this Lcom/juandou/mediapikcer/SubClass1; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

  @Lkotlin/Metadata;(mv={1, 1, 13}, bv={1, 0, 3}, k=1, d1={"\u0000\u000c\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0008\u0002\u0018\u00002\u00020\u0001B\u0005\u00a2\u0006\u0002\u0010\u0002\u00a8\u0006\u0003"}, d2={"Lcom/juandou/mediapikcer/SubClass1;", "Lcom/juandou/mediapikcer/SealedClass;", "()V", "app_debug"})
  // compiled from: Test.kt
}

上面是子类SubClass1的字节码，关键的代码就在于下面：

INVOKESPECIAL com/juandou/mediapikcer/SealedClass.<init> (Lkotlin/jvm/internal/DefaultConstructorMarker;)V

这句字节码片段表明，子类SubClass1在其无参构造方法中调用了kotlin为私密类生成的public共有构造方法，进而完成了构造方法的初始化。

至此，一切真相大白。