阅读 5835

Kotlin:数据类、密封类

天才就是1%的灵感加上99%的汗水,但那1%的灵感是最重要的,甚至比那99%的汗水都要重要

                        ——爱迪生

在前面几个章节章节中,详细的讲解了Koltin中的接口(Interface)枚举(Enmu)。在今天的章节中,为大家详细讲解数据类密封类

目录

一、数据类

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

1.1、关键字

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

1.1.1、声明格式

data class 类名(var param1 :数据类型,...){}
复制代码

或者

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

说明:

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

例:定义一个名为Person的数据类

data class Preson(var name : String,val sex : Intvar age : Int)
复制代码

1.1.2、约定俗成的规定

  • 数据类也有其约定俗成的一些规定,这只是为增加代码的阅读性。即,当构造函数中的参过多时,为了代码的阅读性,一个参数的定义占据一行。

例:

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){
    // something...
}
复制代码

1.1.3、编辑器为我们做的事情

当我们声明一个数据类时,编辑器自动为这个类做了一些事情,不然它怎么又比Java简洁呢。它会根据主构造函数中所定义的所有属性自动生成下列方法:

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

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

1.2、数据类的特性

数据类有着和Kotlin其他类不一样的特性。除了含有其他类的一些特性外,还有着其独特的特点。并且也是数据类必须满足的条件:

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

1.3、用实例说明简洁性

1.3.1、数据类的对比

Kotlin版:

data class User(var name : Stringvar 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 + '\'' +
                '}';
    }
}
复制代码

分析:实现同一个功能,从代码量来说,KoltinJava少了很多行代码,比起更简洁。

1.3.2、修改数据类属性

例:修改User类的name属性

Kotlin版:

Koltin要修改数据类的属性,若属性使用val修饰,则只能使用其独有的copy()函数。其作用就是:修改部分属性,但是保持其他不变,若用var修饰,也可以用Setter()函数修改,这一点和Java一样

val mUser = User("kotlin","123456")
println(mUser)
mUser.name = "first new kotlin"
println(mUser)
val mNewUser = mUser.copy(name = "second new Kotlin")
println(mNewUser)
复制代码

输出结果为:

User(name=kotlin, pwd=123456)
User(name=first new kotlin, pwd=123456)
User(name=second 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'}
复制代码

1.4、解构声明

  • 在前面讲到,Kotlin中定义一个数据类,则系统会默认自动根据参数的个数生成component1() … componentN()函数。其…,componentN()函数就是用于解构声明的
val mUser = User("kotlin","123456")
val (name,pwd) = mUser
println("name = $name\tpwd = $pwd")
复制代码

输出结果为:

name = kotlin    pwd = 123456
复制代码

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

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

1.5.1、源码分析

@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类需要传递三个参数。

1.5.2、用法

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类中的第二个参数替换
复制代码

输出结果为:

(12)      (123)
[1, 2]
[1, 2, 3]
((12), 3)
复制代码

二、密封类

密封类是用来表示受限的类继承结构

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

  • 所谓受限的类继承结构,即当类中的一个值只能是有限的几种类型,而不能是其他的任何类型。
  • 这种受限的类继承结构从某种意义上讲,它相当于是枚举类的扩展。但是,我们知道Kotlin的枚举类中的枚举常量是受限的,因为每一个枚举常量只能存在一个实例。
  • 但是其和枚举类不同的地方在于,密封类的一个子类可以有可包含状态的多个实例。
  • 也可以说成,密封类是包含了一组受限的类集合,因为里面的类都是继承自这个密封类的。但是其和其他继承类(open)的区别在,密封类可以不被此文件外被继承,有效保护代码。但是,其密封类的子类的扩展是是可以在程序中任何位置的,即可以不在同一文件下。

2.2、关键字

定义密封类的关键字:sealed

声明格式

sealed class SealedExpr()
复制代码

PS:密封类是不能被实例化的

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

既然密封类是不能实例化,那么我们要怎么使用,或者说它的作用是什么呢?

2.3、作用及用法

2.3.1、作用

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

例:

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

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

// 其子类可以定在密封类外部,但是必须在同一文件中。`v1.1`之前只能定义在密封类内部
object NotANumber : SealedExpr() 
复制代码

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

2.3.2、和普通继承类的区别

  • 普通的继承类使用open关键字定义,在项目中的类都可继承至该类。
  • 而密封类的子类必须是在密封类的内部或必须存在于密封类的同一文件。这一点就是上面提到的有效的代码保护。

2.3.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
复制代码

2.3.4、子类的类扩展实例

例:

// 其存在于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
复制代码

说明:上面的扩展功能没有任何的意义,只是为了给大家展示密封类子类的扩展不局限与密封类同文件这一个功能而已

3.5、使用密封类的好处

  • 有效的保护代码
  • 在使用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
复制代码

三、总结

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

本文已收录至GitHub: Jetictors/KotlinLearn,欢迎star

文章持续更新中,可以微信搜索「J佬杂谈 」第一时间阅读, 大家的三连击是对老J最好的动力了,你确定不来一波吗?

如果本篇博客有任何错误和建议,欢迎人才们留言


啊喂,五指菇娘啊,拿着手机扫描一下吧!