Kotlin——中级篇（六）：数据类（data）、密封类（sealed）详解

在前面几个章节章节中，详细的讲解了Koltin中的接口类（Interface）、枚举类（Enmu）,还不甚了解的能够查看个人上一篇文章Kotlin——中级篇（五）：枚举类（Enum）、接口类（Interface）详解。固然，在Koltin中，除了接口类、枚举类以外，还有抽象类、内部类、数据类以及密封类。在今天的章节中，为你们详细讲解数据类和密封类。在下一章节中，再为你们奉上Kotlin中的抽象类以及内部类的知识。若是还对Kotlin中类的分类还不清楚的能够查看个人另外一篇博文Kotlin——中级篇（一）：类（class）详解。

目录

1、数据类

• 在Java中，或者在咱们平时的Android开发中，为了解析后台人员给咱们提供的接口返回的Json字符串，咱们会根据这个字符串去建立一个类或者实例对象，在这个类中，只包含了一些咱们须要的数据，以及为了处理这些数据而所编写的方法。这样的类，在Kotlin中就被称为数据类。

一、关键字

声明数据类的关键字为：data

1.一、声明格式

data class 类名(var param1 ：数据类型,...){}

或者

data class 类名 可见性修饰符 constructor(var param1 : 数据类型 = 默认值,...)

说明：

• data为声明数据类的关键字，必须书写在class关键字以前。
• 在没有结构体的时候，大括号{}可省略。
• 构造函数中必须存在至少一个参数，而且必须使用val或var修饰。这一点在下面数据类特性中会详细讲解。
• 参数的默认值无关紧要。（若要实例一个无参数的数据类，则就要用到默认值）

例：

// 定义一个名为Person的数据类
data class Preson(var name : String,val sex : Int, var age : Int)

1.二、约定俗成的规定

• 数据类也有其约定俗成的一些规定，这只是为增长代码的阅读性。

即，当构造函数中的参过多时，为了代码的阅读性，一个参数的定义占据一行。

例：

data class Person(var param1: String = "param1",
              var param2: String = "param2", 
              var param3 : String,
              var param4 : Long,
              var param5 : Int = 2,
              var param6 : String,
              var param7 : Float = 3.14f,
              var param8 : Int,
              var param9 : String){
    // exp
    .
    .
    .
}

1.三、编辑器为咱们作的事情

当咱们声明一个数据类时，编辑器自动为这个类作了一些事情，否则它怎么又比Java简洁呢。它会根据主构造函数中所定义的全部属性自动生成下列方法：

• 生成equals()函数与hasCode()函数
• 生成toString()函数，由类名（参数1 = 值1，参数2 = 值2，....）构成
• 由所定义的属性自动生成component1()、component2()、...、componentN()函数，其对应于属性的声明顺序。
• copy()函数。在下面会实例讲解它的做用。

其中，当这些函数中的任何一个在类体中显式定义或继承自其基类型，则不会生成该函数

二、数据类的特性

数据类有着和Kotlin其余类不同的特性。除了含有其余类的一些特性外，还有着其独特的特色。而且也是数据类必须知足的条件：

• 主构造函数须要至少有一个参数
• 主构造函数的全部参数须要标记为 val 或 var；
• 数据类不能是抽象、开放、密封或者内部的；
• 数据类是能够实现接口的，如(序列化接口)，同时也是能够继承其余类的，如继承自一个密封类。

三、用实例说明其比Java的简洁性

3.一、数据类的对比

Kotlin版：

data class User(val name : String, val pwd : String)

Java版：

public class User {
    private String name;
    private String pwd;

    public User(){}

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

分析：实现同一个功能，从代码量来讲，Koltin比Java少了不少行代码，比起更简洁。

3.二、修改数据类属性

例：修改User类的name属性

Kotlin版：

• Koltin要修改数据类的属性，则使用其独有的copy()函数。其做用就是：修改部分属性，可是保持其余不变

val mUser = User("kotlin","123456")
println(mUser)
val mNewUser = mUser.copy(name = "new Kotlin")
println(mNewUser)

输出结果为：

User(name=kotlin, pwd=123456)
User(name=new Kotlin, pwd=123456)

Java版：

User mUser = new User("Java","123456");
System.out.println(mUser);
mUser.setName("new Java");
System.out.println(mUser);

输出结果为：

User{name='Java', pwd='123456'}
User{name='new Java', pwd='123456'}

分析：从上面对两种方式的实现中能够看出，Kotlin是使用其独有的copy()函数去修改属性值，而Java是使用setXXX()去修改

四、解构声明

• 在前面讲到，Kotlin中定义一个数据类，则系统会默认自动根据参数的个数生成component1() ... componentN()函数。其...,componentN()函数就是用于解构声明的

val mUser = User("kotlin","123456")
val (name,pwd) = mUser
println("name = $name\tpwd = $pwd")

输出结果为：

name = kotlin   pwd = 123456

五、系统标准库中的标准数据类

• 标准库提供了 Pair 和 Triple。尽管在不少状况下命名数据类是更好的设计选择， 由于它们经过为属性提供有意义的名称使代码更具可读性。
• 其实这两个类的源码部分很少，故而贴出这个类的源代码来分析分析

5.一、源码分析

@file:kotlin.jvm.JvmName("TuplesKt")
package kotlin

// 这里去掉了源码中的注释
public data class Pair<out A, out B>(
        public val first: A,
        public val second: B) : Serializable {
    
    // toString()方法
    public override fun toString(): String = "($first, $second)"
}

// 转换
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

// 转换成List集合
public fun <T> Pair<T, T>.toList(): List<T> = listOf(first, second)

// 这里去掉了源码中的注释
public data class Triple<out A, out B, out C>(
        public val first: A,
        public val second: B,
        public val third: C ) : Serializable {

    // toString()方法
    public override fun toString(): String = "($first, $second, $third)"
}

// 转换成List集合
public fun <T> Triple<T, T, T>.toList(): List<T> = listOf(first, second, third)

分析：从上面的源码能够看出，标准库中提供了两个标准的数据类，Pair类以及Triple类.其中：

• 两个类中都实现了toList()方法以及toString()方法。
• to()方法乃Pair类特有，起做用是参数转换
• Pair类须要传递两个参数，Triple类须要传递三个参数。

5.二、用法

val pair = Pair(1,2)        // 实例
val triple = Triple(1,2,3)  // 实例
println("$pair \t $triple") // 打印：即调用了各自的toString()方法
println(pair.toList())      // 转换成List集合
println(triple.toList())    // 转换成List集合
println(pair.to(3))         // Pair类特有: 其做用是把参数Pair类中的第二个参数替换

输出结果为：

(1, 2)   (1, 2, 3)
[1, 2]
[1, 2, 3]
((1, 2), 3)

2、密封类

密封类是用来表示受限的类继承结构。若还不甚清楚Kotlin的类继承，请参见个人上一篇文章Kotlin——中级篇（四）：继承类详解。

一、什么是受限的类继承结构

• 所谓受限的类继承结构，即当类中的一个值只能是有限的几种类型，而不能是其余的任何类型。
• 这种受限的类继承结构从某种意义上讲，它至关因而枚举类的扩展。可是，咱们知道Kotlin的枚举类中的枚举常量是受限的，由于每个枚举常量只能存在一个实例。若对Kotlin中的枚举类不甚了解的，请参见个人另外一篇文章Kotlin——中级篇（五）：枚举类（Enum）、接口类（Interface）详解。
• 可是其和枚举类不一样的地方在于，密封类的一个子类能够有可包含状态的多个实例。
• 也能够说成，密封类是包含了一组受限的类集合，由于里面的类都是继承自这个密封类的。可是其和其余继承类（open）的区别在，密封类能够不被此文件外被继承，有效保护代码。可是，其密封类的子类的扩展是是能够在程序中任何位置的，便可以再也不统一文件下。

上面的几点内容是密封类的特色，请详细的看下去，小生会对这几点内容进行详细的分析。

二、关键字

定义密封类的关键字：sealed

2.一、声明格式

sealed class SealedExpr()

注意：密封类是不能被实例化的

即

val mSealedExpr = SealedExpr()  // 这段代码是错误的，编译器直接会报错不能编译经过。

既然密封类是不能实例化，那么咱们要怎么使用，或者说它的做用是什么呢？请继续往下看

三、密封类的做用及其详细用法。

3.一、做用

用来表示受限的类继承结构。

例：

sealed class SealedExpr{
data class Person(val num1 : Int, val num2 : Int) : SealedExpr()

object Add : SealedExpr()   // 单例模式
object Minus : SealedExpr() // 单例模式
}

// 其子类能够定在密封类外部，可是必须在同一文件中 v1.1以前只能定义在密封类内部
object NotANumber : SealedExpr()

分析：即所定义的子类都必须继承于密封类，表示一组受限的类

3.二、和普通继承类的区别

• 咱们知道普通的继承类使用open关键字定义，在项目中的类均可集成至该类。若是你对Koltin的继承类还不甚了解。请参见个人另外一篇文章Kotlin——中级篇（四）：继承类详解。
• 而密封类的子类必须是在密封类的内部或必须存在于密封类的同一文件。这一点就是上面提到的有效的代码保护。

3.三、和枚举类的区别

• 枚举类的中的每个枚举常量都只能存在一个实例。而密封类的子类能够存在多个实例。

例：

val mPerson1 = SealedExpr.Person("name1",22)
println(mPerson1)

val mPerson2 = SealedExpr.Person("name2",23)
println(mPerson2)

println(mPerson1.hashCode())
println(mPerson2.hashCode())

输出结果为：

Person(name=name1, age=22)
Person(name=name2, age=23)
-1052833328
-1052833296

3.四、其子类的类扩展实例

• 在Kotlin支持扩展功能，其和C#、Go语言相似。这一点是Java没有的。若是你还对Koltin中的扩展功能还不甚清楚的。请参见个人另外一篇博文Kotlin——扩展功能详解

为了演示密封类的子类的扩展是能够在项目中的任何位置这个功能，你们能够下载源码。源码连接在文章末尾会为你们奉上。
例：

// 其存在于SealedClassDemo.kt文件中

sealed class SealedExpr{
    data class Person(val name : String, val age : Int) : SealedExpr()
    object Add : SealedExpr()
    companion object Minus : SealedExpr()
}

object NotANumber : SealedExpr()

其存在TestSealedDemo.kt文件中

fun  <T>SealedExpr.Add.add(num1 : T, num2 : T) : Int{
    return 100
}

fun main(args: Array<String>) {
    println(SealedExpr.Add.add(1,2))
}

输出结果为：

100

说明：上面的扩展功能没有任何的意义，只是为了给你们展现密封类子类的扩展不局限与密封类同文件这一个功能而已。若是你还对Koltin中的扩展功能还不甚清楚的。请参见个人另外一篇博文Kotlin——扩展功能详解

3.五、使用密封类的好处

• 有效的保护代码（上面已说明缘由）
• 在使用when表达式 的时候，若是可以验证语句覆盖了全部状况，就不须要为该语句再添加一个else子句了。

例：

sealed class SealedExpr{
    data class Person(val name : String, val age : Int) : SealedExpr()
    object Add : SealedExpr()
    companion object Minus : SealedExpr()
}

object NotANumber : SealedExpr()

fun eval(expr: SealedExpr) = when(expr){
    is SealedExpr.Add -> println("is Add")
    is SealedExpr.Minus -> println("is Minus")
    is SealedExpr.Person -> println(SealedExpr.Person("Koltin",22))
    NotANumber -> Double.NaN
}

输出结果为：

is Minus

3、总结

在实际的项目开发当中，数据类(data)类的用处是不少的，由于在开发APP时，每每会根据后台开发者所提供的接口返回的json而生成一个实体类，如今咱们学习了数据类后，就不用再像Java同样写那么多代码了，即便是用编辑器提供的方法去自动生成。可是代码量上就能节省咱们不少时间，而且也更加简洁。何乐而不为呢!密封类的状况在实际开发中不是很常见的。只有当时特殊的需求会用到的时候，才会使用密封类。固然咱们仍是要学习的。

源代码

若是各位大佬看了以后感受还阔以，就请各位大佬随便star一下，您的关注是我最大的动力。
个人我的博客：Jetictors
个人github：Jetictors
个人掘金：Jetictors

欢迎各位大佬进群共同研究、探索

QQ群号：497071402