Kotlin学习之 11数据类与密封类

叁歲伎倆 2022-05-26 05:24 317阅读 0赞

# Kotlin 数据类与密封类 #

## 一.数据类 ##

### 1.Kotlin 可以创建一个只包含数据的类，关键字为 data： ###

data class User(val name: String, val age: Int)

### 2.编译器会自动的从主构造方法中根据所有声明的属性提取以下方法： ###

equals() / hashCode()
    toString() 格式如 "User(name=John, age=42)"
    componentN() functions 对应于属性，按声明顺序排列
    copy() 方法

### 3.如果这些方法在类中已经被明确定义了，或者从超类中继承而来，就不再会生成。 ###

为了保证生成代码的一致性以及有意义，数据类需要满足以下条件：

主构造方法至少包含一个参数。

所有的主构造方法的参数必须标识为val 或者 var ;

数据类不可以声明为 abstract, open, sealed 或者 inner;

数据类不能继承其他类 (但是可以实现接口)。

## 二.复制 ##

### 1.复制使用 copy() 方法，我们可以使用该方法复制对象并修改部分属性, ###

对于上文的 User 类，其实现会类似下面这样：

fun copy(name: String = this.name, age: Int = this.age) = User(name, age)

### 2.实例 ###

使用 copy 类复制 User 数据类，并修改 age 属性:

data class User(val name: String, val age: Int)
    
    
    fun main(args: Array<String>) {
        val jack = User(name = "Jack", age = 1)
        val olderJack = jack.copy(age = 2)//可以修改一个属性，也可以修改两个属性
        println(jack)
        println(olderJack)
    
    }

#### 输出结果为： ####

User(name=Jack, age=1)
    User(name=Jack, age=2)

上面代码中修改属性的时候，属性的类型要和前面定义的一致

### 三.数据类以及解构声明 ###

### 组件方法允许数据类在解构声明中使用： ###

data class User(val name: String, val age: Int)
    
    
    fun main(args: Array<String>) { 
    
        val jane = User("Jane", 35)
        val (name, age) = jane  //Kotlin中居然可以这样声明和初始化属性！
        println("$name, $age years of age") // prints "Jane, 35 years of age"
    }

#### 打印结果： ####

Jane, 35 years of age

上面

val (name, age) = jane

其实就相当于

val name=jane.name
    val age=jane.age

## 四.标准数据类 ##

### 1.标准库提供了 Pair 和 Triple 。 ###

在大多数情形中，命名数据类是更好的设计选择，因为这样代码可读性更强而且提供了有意义的名字和属性。

什么意思呢？  
其实pair相关与java中的Map集合类，数据存储方式是key-value  
Triple就不知道怎么说了，也是类似集合，可以三个数据一起那种的。

### 2.示例 ###

fun main(args: Array<String>) {
        val a1=Pair(1,"a1")
        val a2=Pair(2,"a2")
        println(a1)
        println(a2)
    
        //Pair的类型可以不固定
        val map = mapOf(Pair(1, "A"), Pair("2", 500))
        for (entry in map) {
            println("${entry.key},${entry.value}")  //获取里面的key和value
            println("${entry.key.javaClass},${entry.value.javaClass}")//获取key、value对应的类型
        }
    
        val (i, j, k) = Triple(1, "a", 2.0)//可以存放不同类型的数据
        println("$i , $j , $k")   //获取数值
        println(i.javaClass.name+" , "+j.javaClass.name+" , "+k.javaClass.name)//获取数值的类型
    
    
        val v = Triple(1, "SB", 3) //只能三个
        println("${v.first},${v.second},${v.third}")
    
    }

### 程序运行结果： ###

(1, a1)
    (2, a2)
    1,A
    class java.lang.Integer,class java.lang.String
    2,500
    class java.lang.String,class java.lang.Integer
    1 , a , 2.0
    int , java.lang.String , double
    1,SB,3

这个东西跟java相比也是一个奇葩。

## 五.密封类 ##

### 1.密封类用来表示受限的类继承结构：当一个值为有限几种的类型, 而不能有任何其他类型时。 ###

在某种意义上，他们是枚举类的扩展：枚举类型的值集合 也是受限的，  
但每个枚举常量只存在一个实例，而密封类 的一个子类可以有可包含状态的多个实例。

声明一个密封类，使用 sealed 修饰类，密封类可以有子类，但是所有的子类都必须要内嵌在密封类中。

sealed 不能修饰 interface ,abstract class(会报 warning,但是不会出现编译错误)

sealed class Expr //定义一个密封类
    
    data class Const(val number: Double) : Expr() //定义密封类的子类Const
    
    data class Sum(val e1: Expr, val e2: Expr) : Expr() //定义密封类的子类Sum
    
    object NotANumber : Expr() //？？？
    
    fun eval(expr: Expr): Double = when (expr) {//返回一个浮点数的方法
        is Const -> expr.number
        is Sum -> eval(expr.e1) + eval(expr.e2)
        NotANumber -> Double.NaN
    }

使用密封类的关键好处在于使用 when 表达式 的时候，如果能够验证语句覆盖了所有情况，就不需要为该语句再添加一个 else 子句了。

fun eval(expr: Expr): Double = when(expr) {
        is Expr.Const -> expr.number
        is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
        Expr.NotANumber -> Double.NaN
        // 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
    }

看完上面Kotliin中，密封类，好像有点懂，但是不知道怎么运用，运行。

### 2.网上看了一个示例： ###

/**
     * 密封类
     * 1.密封类用sealed关键词表示
     * 2.密封类的子类只能定义在密封类的内部或同一个文件中，因为其构造方法为私有的
     * 3.密封类相比于普通的open类，可以不被此文件外被继承，有效保护代码
     * 4.与枚举的区别：密封类适用于子类可数的情况，枚举适用于实例可数的情况
     */
    
    
    sealed class PlayerCmd { //演奏控制类（密封类）
        val playerName: String = "Player"
    
        //演奏类
        class Player(val url: String, val position: Long = 0): PlayerCmd() { 
            fun showUrl() {
                println("$url, $position")
            }
        }
    
        class Seek(val position: Long): PlayerCmd() //快进
    
        object Pause: PlayerCmd() //暂停（无需进行重载的类适合用单例object）
    }
    
    //（密封类的子类也可以定义在密封类的外部，但要在同一个文件中）
    object Resume: PlayerCmd() //继续
    
    object Stop: PlayerCmd() //停止
    
    enum class PlayerState { //枚举适合表现简单的状态
        IDLE, PAUSE, PLAYING, STOP
    }
    
    fun main(args: Array<String>) {
        PlayerCmd.Player("苍茫的天涯").showUrl()
        println(Resume.playerName)
    }

### 运行结果： ###

苍茫的天涯, 0
    Player

看完上面这个示例，感觉更加懵逼了！

### 3.上网看了另一个简单的示例 ###

sealed class Time
    
    data class Time1(val number: Int) : Time() 
    
    data class Time2(val number: Int, val name: String) : Time() 
    
     fun main(args: Array<String>) {
            println(list(Time1(5)))
            println(list(Time2(8,"hehe")))
    }
    
     fun list(time:Time) : String = when(time){
           is Time1 -> "${time.number}"
           is Time2 -> time.name
       }

上面的代码是可以直接放到文件中测试运行的

#### 运行结果： ####

5
    hehe

看完这个示例，我就知道刚开始那个代码应该怎样运行了。

Kotlin中方法是可以不写在类里面的，main方法是肯定不写在类里面的！

### 4.密封类最开始的代码的示例 ###

sealed class Expr //定义一个密封类
    
    data class Const(val number: Double) : Expr() //定义密封类的子类Const
    
    data class Sum(val e1: Expr, val e2: Expr) : Expr() //定义密封类的子类Sum
    
    object NotANumber : Expr() //???,后面查了一下，其实object就像java中的static静态作用，但是用过不同，看下面调用吧
    
    fun eval(expr: Expr): Double = when (expr) {
       //返回一个浮点数的方法
        is Const -> expr.number
        is Sum -> eval(expr.e1) + eval(expr.e2)
        NotANumber -> Double.NaN
    }
    
     fun main(args: Array<String>) {
            println(eval(Const(5.0)))//5.0
            println(eval(Sum(Const(5.0),Const(15.0))))//5.0+15.0
            println(eval(NotANumber)) //因为NotANumber是静态的，不是方法
    }

代码运行结果：

5.0
    20.0
    NaN

到这里Kotlin奇葩的数据类就介绍到这里了。  
上面所有的示例，都是可以在线测试的，可以测试体验一把！  
[https://blog.csdn.net/wenzhi20102321/article/details/79859347][https_blog.csdn.net_wenzhi20102321_article_details_79859347]

# 共勉：坚持做一件事情你就会有更多的时间和更多的精力。 #

[https_blog.csdn.net_wenzhi20102321_article_details_79859347]: https://blog.csdn.net/wenzhi20102321/article/details/79859347