kotlin中的特殊类

一:数据类

1.1：使用

我们经常创建一些数据类来保存一个对象的属性和状态，在这些类中一些标准的get set函数都是机械推导出来的，在kotlin中这些类被标记为数据类，使用关键字data声明

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

编译器自动从数据类主构造函数中的属性推导出一下成员

• equals/hashcode对
• toString格式是“User(name=tian,age=12)"
• componentN():函数按声明顺序对应所有属性
• copy能力

数据类中的成员生成遵循成员继承的规则，

• 如果数据类中有显示的实现toString equals等函数，或者在超类中这些函数有final实现，则不会生产这些函数，而是使用现有函数
• 不允许对componentN以及copy函数提供显示实现
• 如果数据类需要一个无参构造函数，则主构造函数的所有属性必须有默认值

data class User(val name: String = "", val age: Int = 1) //这里就会有无参构造函数

1.2：在类体中声明属性

注意：数据类中自动生产的函数只会用到主构造函数中的参数，如果有在类体中声明的属性，则不会用到

data class User(var name: String) {
    var age: Int = 0  // 这个属性不会在自动生成的函数中出现
}

1.3：copy函数

很多时候我们需要改变数据类对象的一个属性，而保持其他的不变，我们就可以使用copy函数

var user = User("tian", 12)
var olderUser = user.copy(age = 21)

二:密封类

密封类表示有限的类继承结构，当一个值为有限集中的类型，而不能有任何其他类型时。可以理解它为枚举类的扩展。密封类使用sealed修饰，默认是open的类，
注意:密封类和它的子类都必须声明在相同的文件中

sealed class Person
object Man : Person()
object Woman : Person()
fun test(person: Person) {
    when(person) {
        is Man -> println("man")
        is Woman -> println("woman")
    }
}

可以看到这里的when没有了else，这是密封类最常用的时候，密封类因为有有限的类继承结构，所以在使用when时我们可以全部覆盖密封类的子类，但我们临时添加一个子类时，在编译时when因为没有全部覆盖密封类的子类，就会报错，这样我们就能在编译期间查询到错误，更容易使程序健壮
特点：密封类默认是抽象的无法实例化，构造函数默认是private的，

三:嵌套类

类也可以嵌套在其他类中， 无法访问外部类

class Outer{
      private val bar:Int = 1
      class Nested{
          fun foo() = 2
      }
}

val demo = Outer.Nested().foo()

四:内部类

内部类与嵌套类不同为它可以访问外部类，内部类使用inner标记，内部类会有一个对外部类的对象引用。

class Outer{
      private val bar:Int = 1
      inner class Nested{
          fun foo() = bar
      }
}

val demo = Outer.Nested().foo()  //demo = 1

五:枚举类

:5.1:基本使用

枚举类最基本的用法是实现类型安全的枚举，每个枚举常量都是一个对象，多个常量用逗号分割

enum class Direction{
    NORTH, SOUTH, WEST, EAST
}
enum class TIme(var number: Int){   //带参数的枚举类
     HOUR(1),
    YEAR(2),
    SECOND(3)
}

5.2：枚举类中的自定义成员

枚举类中也可以有自己的匿名类，相应的方法，以及覆盖基类的方法，
注意:枚举类内定义任何成员需要跟枚举成员对象用分号隔开

enum class Time(val age: Int) {
    HOUR(1) {
        override fun sign() = HOUR
    },
    YEAR(2){
        override fun sign() = YEAR
    },
    SECOND(3){
        override fun sign() = SECOND
    }; //在这里用分号把枚举类成员对象和枚举类内定义的成员分开

    abstract fun sign(): Time
}

5.3：枚举类的接口实现

枚举类可以实现接口但不能继承类，可以为所有枚举类成员对象提供统一的实现，也可以在相应的匿名类中单独实现，

interface ITime {
    fun test()
}
enum class Time(val age: Int) : ITime {
    HOUR(1) {
        override fun sign() = HOUR
        override fun test() {    //这里是为所有枚举类成员对象单独实现接口成员
            super.test()   //这里的super代表的就是Time枚举类，这个调用的是Time中的test函数
            println("Hour test")
        }
    },
    YEAR(2){
        override fun sign() = YEAR
    },
    SECOND(3){
        override fun sign() = SECOND
    };

    abstract fun sign(): Time

    override fun test() {  //这里是为所有枚举类成员对象统一实现接口成员
        println("Time test")
    }
}

5.4:使用枚举类

枚举类可以使用valueOf和values函数来进行访问

    val time = Time.valueOf("YEAR")   //根据参数YEAR,从Time枚举类中获取YEAR，传入的字符串就是枚举类对象成员的名字
    val times = Time.values()  //这里会获取Time枚举类中所有的对象成员，返回的是Array类型
    for (t in times) {
        println(t)
    }

使用enumValueOf和enumValues函数这两个函数与上面两个函数返回的结果是一样的

    enumValueOf<Time>("YEAR")    //使用泛型指定要操作的枚举类，返回值为TIme
    enumValues<Time>()     //返回为TIme的Array类型