kotlin 中的数据类型、泛型、枚举_kotlin data class 泛型

Kotlin 中可以创建包含数据的类，使用的关键字为 data，比如说 data class Student(val name: String, val age: Int)，编译器会自动重写 equals() 、 hashCode() 、toString() 等方法

fun test(){
    val u = Student("tom", 15)
    val u1 = Student("tom", 15)
    println(u == u1)  //  比较equals() 
    println(u === u1) //  比较地址值
    println(u.hashCode())
    println(u.toString())
    println(u.component1() + "    " + u.component2())  // Student 中的属性，按照顺序排列
    println(u.copy(age = 45))  // 替换 age 的值
}

打印的结果为

true
false
3565821
Student(name=tom, age=15)
tom    15
Student(name=tom, age=45)

Kotlin 中还有个密封类的概念，在我的理解中，它更像是一个枚举的扩展，后面会提到枚举；接下来先看看泛型，Kotlin 中的泛型与 Java 中的类似，用法也差不多，举个容器泛型，看看例子

class ABox<T>(t : T) {
    val value : T = t
}
 
fun test(){
    val i = ABox<Int>(12)
    val j = ABox<String>("Tom")
    val k = ABox(true)
    println("i: ${i.value}   j: ${j.value}   k: ${k.value}")
}

这个例子中，i 和 j 指定了泛型的类型，而 k 则没有，这里用的是类型的推导，可以这么写；运行 test()，打印的值为

i: 12   j: Tom   k: true

我们知道，泛型更多的是用在方法中，比如说方法中有个形参，我们想通过泛型来扩展或保证安全，看例子

open class AAA
 
open class AB : AAA(){
    open fun study(){
        println("AB")
    }
}
 
class AC : AB(){
    override fun study() {
        println("AC")
    }
}
 
fun testPrint(bean : AB){
    bean.study()
}
fun <T : AB>testPrint1(b : T){
    b.study()
}
 
 
fun test(){
    val i = AB()
    val j = AC()
    testPrint(i)
    testPrint(j)
    println()
    testPrint1(i)
    testPrint1(j)
}

testPrint(bean : AB) 是常规写法，testPrint1(b : T) 是添加了泛型的写法，调用 test() 方法，打印的数值为

AB
AC
 
AB
AC

泛型可以这样使用，还可以通过通配符的用法更加精确的控制方法，在 Java 中会在泛型中使用 extend 和 super 来表示生产者和消费者，而在 Kotlin 中，则是以 out 和 in 来表示，并且由于 in 表示消费者，所以不能使用 val 来修饰，见下面

class BA<out AB>(val ab : AB){
    fun foo(): AB {
        return ab
    }
}
 
class BC<in AB>( ab : AB){
    fun foo() {
 
    }
}

关于泛型的讲解，在之前的文章中，effective java 注解中，有过详细的讲解，可以对比思考 ： https://blog.csdn.net/Deaht_Huimie/article/details/82872858 ，Kotlin 中泛型还有个星号的用法，意思是可以添加任何类型的对象

class ABox<T>(val t: T, val t2 : T, val t3 : T)
class Bean(var name : String)
 
fun test(){
    val a: ABox<*> = ABox(12, "Tom", Bean("Jack"))
    val a1: ABox<Any?> = ABox(12, "Tom", Bean("Jack"))
    val bean = a.t3
    val bean1 = a1.t3
    println("$bean    $bean1")
 
    val list:ArrayList<*> = arrayListOf("Tom",1,1.2f,Bean("Jack"))
    for (item in list){
        println(item)
    }
}

运行，调用 test() 方法，打印结果为

com.example.cn.desigin.test.Bean@3af49f1c    com.example.cn.desigin.test.Bean@19469ea2
Tom
1
1.2
com.example.cn.desigin.test.Bean@448139f0

在这里，val a: ABox<*> 和 val a1: ABox<Any?> 的意思是一样的，都是指在容器 ABox 中可以添加任意类型的对象。

Kotlin 中枚举和 Java 中枚举用法和写法都极为接近，

enum class FRUIT{
    APPLE,ORANGE,BANANA,PEAR,WATERMELON
}
 
fun test(){
    var fruit:FRUIT=FRUIT.BANANA
    println(FRUIT.values().size)
    println(FRUIT.valueOf("ORANGE"))
    println(fruit.name)
    println(fruit.ordinal)
}

分别打印了枚举的总个数及 BANANA 的名字和序列号，打印的值为

5
ORANGE
BANANA
2

枚举中也可以定义抽象方法，然后让每个枚举对象实现该抽象方法，这里与java中的一模一样。