Kotlin学习——kt中的类，数据类 & 枚举类 & 密封类，以及对象

╰+攻爆jí腚メ 2024-02-17 10:27 60阅读 0赞

![在这里插入图片描述][e2ebf88730c6425e970258ce31df3de2.png]

Kotlin 是一门现代但已成熟的编程语言，旨在让开发人员更幸福快乐。 它简洁、安全、可与 Java 及其他语言互操作，并提供了多种方式在多个平台间复用代码，以实现高效编程。

[https://play.kotlinlang.org/byExample/01\_introduction/02\_Functions][https_play.kotlinlang.org_byExample_01_introduction_02_Functions]

其他关于kt的博客文章如下：

*  [Kotlin学习——hello kotlin & 函数function & 变量 & 类 + 泛型 + 继承][Kotlin_hello kotlin _ _function _ _ _ _ _ _ _]
 *  [Kotlin学习——流程控制，when，循环，range工具 & kt里的equals & if实现类似三元表达式的效果][Kotlin_when_range_ _ kt_equals _ if]

#### 目录 ####

*  引出
 *   *  Data Classes 数据类
     *  Enum classes 枚举类
     *  Sealed classes 密封类
     *  Object Keyword 对象
     *   *  对象表达式 object Expression
         *  对象声明 object Declaration
         *  伴随对象 Companion Objects
 *  总结

## 引出 ##

--------------------

1.kt中的数据类，提供很多默认的常用方法；  
2.kt里可以使用枚举类；  
3.密封类，只能在该类中进行实例化；  
4.对象表达式，对象声明，伴随对象；

### Data Classes 数据类 ###

数据类使创建用于存储值的类变得容易。这样的类会自动提供用于复制、获取字符串表示和在集合中使用实例的方法。

*  使用数据标识符，data 修饰类
 *  toString是自动生成的
 *  拷贝的时候，可以更改某些特性的值
 *  生成的componentN函数，可以按照声明的顺序获取属性的值

![在这里插入图片描述][bb8430027aa04762a0159138e90700ab.png]

package com.tianju.classKt
    
    /**
     * 使用数据标识符，data 修饰类
     */
    data class User(val name: String, val id: Int) {
        
    
        // 重写equals方法
        override fun equals(other: Any?): Boolean {
        
            return other is User && other.id == this.id
        }
    }
    
    fun main() {
        
        val user = User("peter",1)
        // 自动生成toString方法
        println(user)
    
        val shir = User("xueLi",1)
        val per = User("peter",1)
    
        println(shir.hashCode())
        println(per.hashCode())
        // id相同 两个实体类就相同
        println(shir == per)
    
        println(user.copy())
        // 拷贝出一个新的对象，引用不是同一个
        println(user.copy() === user)
    
        // copy的时候可以改某些属性值
        println(user.copy("shir"))
        println(user.copy(id=123))
    
        // 自动生成component1方法，按照顺序获取
        println("user name is ${user.component1()}")
        println("user id is ${user.component2()}")
    
    }

### Enum classes 枚举类 ###

枚举类用于对表示有限组不同值（如方向、状态、模式等）的类型进行建模。

*  通过类名访问枚举常量
 *  使用when语句时，编译器可以推断when表达式是否是穷举的，这样就不需要else情况了

package com.tianju.classKt
    
    /**
     * 定义一个枚举类
     */
    enum class State {
        
        RUNNING,WALKING,SWING
    }
    
    fun main() {
        
        val state = State.RUNNING
        val msg = when(state){
        
            State.SWING -> "he is swing"
            State.WALKING -> "he is walking"
            State.RUNNING -> "he is running"
        }
    
        println(msg)
    }

> 具有属性和方法的枚举类

package com.tianju.classKt
    
    /**
     * 具有属性和方法的枚举类
     */
    enum class Color(val rgb:Int) {
        
        RED(0xFF0000),
        GREEN(0X00FF00),
        BLUE(0X0000FF),
        YELLOW(0XFFFF00);
    
        fun containsRed(): Boolean {
        
            // RED和YELLOW的RGB值共享第一位（FF）
            return (this.rgb and 0XFF000 !=0)
        }
    }
    
    fun main() {
        
        val red = Color.RED
        // 默认的toString返回常量的名称，这里是“RED”
        println(red)
        println(red.containsRed())
    
        // 一路点 过去，类似于python
        println(Color.BLUE.containsRed())
        println(Color.YELLOW.containsRed())
    }

### Sealed classes 密封类 ###

密封类可以限制继承的使用。一旦声明了一个密封的类，就只能在声明密封类的同一个包中对其进行子类化。它不能在声明密封类的包之外进行子类化。

*  使用关键字sealed 定义一个密封类
 *  不需要else的情况，因为密封类的所有可能的子类都被覆盖了

package com.tianju.classKt
    
    /**
     * 使用关键字sealed 定义一个密封类
     */
    sealed class Mammal(val name:String)
    
    // 猫猫
    class Cat(val catName:String):Mammal(catName)
    // 人类
    class Human(val humanName:String,val job:String):Mammal(humanName)
    
    fun greetMammal(m: Mammal): String {
        
        // 不需要else的情况，因为密封类的所有可能的子类都被覆盖了
        when(m){
        
            is Human -> return "hello ${m.humanName} work is ${m.job}"
            is Cat -> return "hello ${m.catName} work is eating"
        }
    }
    
    fun main() {
        
        println(greetMammal(Cat(catName = "Arya")))
    }

### Object Keyword 对象 ###

定义一个类，然后创建该类的多个实例

package com.tianju.classKt
    
    import java.util.Random
    
    class LuckNum {
        
        fun getNum(){
        
            var num = Random()
            println(num.nextInt())
        }
    }
    
    fun main() {
        
        // 创建实例
        val a1 = LuckNum()
        val a2 = LuckNum()
    
        a1.getNum()
        a2.getNum()
    }

#### 对象表达式 object Expression ####

关于单例：

*  Singleton模式：它确保即使有两个线程试图创建该类的一个实例，也只能创建它。
 *  在Kotlin中实现这一点，您只需要声明一个对象：没有类，没有构造函数，只有一个惰性实例。为什么懒惰？因为它将在访问对象时创建一次。否则，它甚至不会被创建。

package com.tianju.classKt
    
    /**
     * 对象表达式
     */
    fun nowPrice(normalDay: Int, discountDay: Int): Unit {
        
    
        val dayRate = object {
        
            val normal:Int = 30*normalDay
            val discount:Int = 100*discountDay
        }
    
        val total = dayRate.normal + dayRate.discount
    
        println("total price is $total")
    }
    
    fun main() {
        
        nowPrice(10,1)
    }

#### 对象声明 object Declaration ####

对象声明，不是表达式，不能在变量赋值中使用。可以使用它来直接访问其成员：

package com.tianju.classKt
    
    /**
     * 创建一个对象声明
     */
    object DoAuth{
        
        // 创建一个方法
        fun takeParams(name:String,psd:String){
        
            println("the name is $name, the password is $psd")
        }
    }
    
    fun main() {
        
        DoAuth.takeParams("PET","123")
    }

#### 伴随对象 Companion Objects ####

类中的对象声明定义了另一种有用的情况：伴随对象。从语法上讲，它类似于Java中的静态方法：使用对象的类名作为限定符来调用对象成员。

package com.tianju.classKt
    
    /**
     * 伴随对象，类似于java中的静态方法
     */
    class BigBen {
        
        // 定义一个伴随对象，名字可以省略
        companion object {
        
            fun getBongs(nTimes: Int){
        
                for (i in 1..nTimes){
        
                    println("Hello $i")
                }
            }
        }
    }
    
    
    fun main() {
        
        // 通过 点. 的方式进行调用
        BigBen.getBongs(10)
    }

--------------------

## 总结 ##

1.kt中的数据类，提供很多默认的常用方法；  
2.kt里可以使用枚举类；  
3.密封类，只能在该类中进行实例化；  
4.对象表达式，对象声明，伴随对象；

[e2ebf88730c6425e970258ce31df3de2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/de583b24a1214659b3f334ec1b0842e3.png
[https_play.kotlinlang.org_byExample_01_introduction_02_Functions]: https://play.kotlinlang.org/byExample/01_introduction/02_Functions
[Kotlin_hello kotlin _ _function _ _ _ _ _ _ _]: https://blog.csdn.net/Pireley/article/details/134505130
[Kotlin_when_range_ _ kt_equals _ if]: https://blog.csdn.net/Pireley/article/details/134618571
[bb8430027aa04762a0159138e90700ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/5b9f4662d46d4000b03ee73bddb2c572.png