一、枚举类

        枚举类，用来定义常量集合的一种特殊类。使用 enum class 可以声明一个枚举类。

enum class EnumClass {
    RED,
    BULE,
    YELLOW
}

fun main() {
    println("---------------使用枚举类-------enumclass.")
    println(EnumClass.BULE)
}

1.2 获取枚举相关信息

1. val name: String //获取枚举名称,,默认名称为枚举字符名

2. val ordinal: Int //获取枚举值在所有枚举数组中定义的顺序,值从 0 开始

    println("\n--------获取枚举类型的相关信息 获取枚举名称--------和顺序------------")
    var color=EnumClass.YELLOW
    println("枚举的名字==${color.name}")
    println("枚举的顺序==".plus(color.ordinal))

1.3 枚举类添加属性

        每一个枚举都是枚举类的实例，它们可以被初始化。

        若需要指定值，则可以使用其构造函数。

//2.0版本
enum class Color2(val user: UserColor) {
    RED(UserColor("小红", 15)),
    BULE(UserColor("小蓝", 20)),
    YELLOW(UserColor("小黄", 30));
}
data class UserColor(val name: String, val age: Int)
fun main() {
    //2.0版本
    println(Color2.BULE.user)
}

1.4 定义函数

enum class Color2(val user: UserColor) {
    ...
    RED(UserColor("小红", 15));
    fun addUser(adduser:UserColor)=
        UserColor("${adduser.name}-${user.name}"
            ,adduser.age+user.age)
 
}
 
fun main() {
    //枚举定义函数
    println(Color2.RED.addUser(UserColor("新", 40)))
}

三、数据类

        使用 data class 关键字创建一个只包含数据的类，这种类又称数据类。这个是Kotlin独有的，Java没有数据类。

编译器会自动的从主构造函数中根据所有声明的属性提取以下函数：

生成 equals() 函数与 hasCode() 函数

生成 toString() 函数，由类名(参数1 = 值1，参数2 = 值2，….) 构成

由所定义的属性自动生成component1()、component2()、…、componentN()函数，其对应于属性的声明顺序。

copy() 函数

数据类需要满足以下条件：

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

所有的主构造函数的参数必须标识为val或者var。

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

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

data class DaTang (var name:String ,val age:Int)
        在没有结构体的时候，大括号{}可省略。
 

data class DataClass (var name:String,val age:Int) {
    var eploy ="$name ==  $age"
}

fun main() {
    println(DataClass("zhangsan",35))
}

3.3 ==符号

data class DaTang (var name:String ,val age:Int){
    val emperor = "$name,是继隋朝之后的大一统中原王朝，共历二十一帝，享国-$age-年。"
}
class DaTang2 (var name:String ,val age:Int){
    val emperor = "$name,是继隋朝之后的大一统中原王朝，共历二十一帝，享国-$age-年。"
}
fun main() {
    println(DaTang("唐朝", 289))
    // "==“比较的是内容  equals(Any)。
    // 因未重写Any的equals函数，使用的是Any默认equals函数，所以比较的还是引用。
    // "===" 比较的是引用(类所占的内存区域)
    println(DaTang2("唐朝", 289) == DaTang2("唐朝", 289))
 
    //这里使用的是data class，数据类重写了equals，比较的是数据类里面的数据。
    println(DaTang("唐朝", 289) == DaTang("唐朝", 289))
}

 

3.4 copy() 函数

copy() 函数应该是类似Java中的clone() 方法

data class DaTang (var name:String ,val age:Int){
    val emperor = "$name,是继隋朝之后的大一统中原王朝，共历二十一帝，享国-$age-年。"
}
fun main() {
    val datang = DaTang("唐朝", 289)
    println(datang)//DaTang(name=唐朝, age=289)
    //创建了了一个新的对象
    val diguo = datang.copy(age=500)
    println(diguo)//DaTang(name=唐朝, age=500)
 
}

3.5 解构声明
        数据类：由所定义的属性自动生成component1()、component2()、…、componentN()函数，其对应于属性的声明顺序。

        普通类：使用 operator 关键字定义component1()、component2()、…、componentN()函数。

data class DataDaSong(var name:String ,var age:Int)
class DaSong(var name:String ,var age:Int){
    //解构语法：必须从component1开始
    operator fun component1() = name
    operator fun component2() = age
}
 
fun main() {
    //使用普通类需要自己写component1、component2...componentN
    var (name,age) = DaSong("北宋",167)
    println("$name,是中国历史上继五代十国之后的朝代，传九位皇帝，享国-$age-年")
    //使用数据类支持解构语法，自动生成operator fun component1
    var (dataname,dataage) = DataDaSong("北宋",167)
    println("数据类：$dataname,是中国历史上继五代十国之后的朝代，传九位皇帝，享国-$dataage-年")
}

四，继承

     Kotlin 允许一个类继承自另一个类，Kotlin 中所有类都继承自 Any 类，Any 类是所有类的超类，对于没有超类型声明的类是默认超类

        Kotlin 类默认都是封闭的，要让某个类开放继承，必须使用 open 关键字修饰它。

在 Kotlin 中 Any 类是所有类的超类

在 Java 中 Object 类是所有类的超类
 

Any 默认提供了三个函数：

public open class Any {
    
    public open operator fun equals(other: Any?): Boolean
 
    public open fun hashCode(): Int
 
    public open fun toString(): String
}
 

定义要被继承的类  使用 open 关键字进行修饰。

在基类中，使用 fun 声明函数时，此函数默认为 final 修饰，不能被子类重写。

 如果允许子类重写该函数，那么必须使用 open 关键字修饰它, 子类重写函数使用 override 关键字。

//类必须用 open 关键字修饰  才能被继承，
open class Food{
    //函数必须用 open 关键字修饰，子类才能覆盖
    open  fun info()="继承类基础类"
}

class Banana:Food(){
    //使用 override 关键字覆盖父类函数
    override fun info(): String {
        return super.info()+" 被继承类"
    }

}

fun main() {
    var food:Food =Banana()
  println(  food.info())
}

构造函数

子类有主构造函数

如果子类有主构造函数， 则基类必须在主构造函数中立即初始化

open Person(var name:String,var age:Int){

}

open Studen(name:String,age:Int ,var no :String):Person(name,age){

}