Kotlin语法-Day8

1.1 枚举类

1.枚举类的值等于枚举本身 例如Person4Enum.Wang_wu == Person4Enum
2.枚举的主构造参数必须和枚举的参数保持一致
3.枚举参数类型实际上就是枚举类的item类型

//TODO Kotlin语言中的枚举类
/*
*
*   1.枚举类的值等于枚举本身  例如Person4Enum.Wang_wu  ==  Person4Enum
*   2.枚举的主构造参数必须和枚举的参数保持一致
*   3.枚举参数类型实际上就是枚举类的item类型
* */
class Person4(var name:String,var age:Int)
enum class Person4Enum(var person4: Person4){
    Zhang_san(Person4("张三",20)),
    Li_si(Person4("李四",22)),
    Wang_wu(Person4("王五",23));
    fun show()="名字是：${person4.name},年龄是：${person4.age}"
}
fun main() {
    println(Person4Enum.Wang_wu.show())
    println(Person4Enum.Zhang_san.show())
    println(Person4Enum.Li_si.show())

    println()
    println(Person4Enum.Wang_wu is Person4Enum)

}

---

1.2 密封类

sealed 必须有类型且继承本类

//TODO Kotlin语言中的密封类
/*
*   sealed 必须有类型且继承本类
* */
sealed class Exams{
   object Item1:Exams()       //没有参数用object
   object Item2:Exams()
   object Item3:Exams()
   class Item4(var name:String) :Exams()
}
class Teachers(var exams: Exams){
   fun show()=when(exams){
       is Exams.Item1 ->1
       is Exams.Item2 ->2
       is Exams.Item3 ->3
       is Exams.Item4 -> (exams as Exams.Item4).name
   }
}
fun main() {
   println(Teachers(Exams.Item1).show())
   println(Teachers(Exams.Item2).show())
   println(Teachers(Exams.Item3).show())
   println(Teachers(Exams.Item4("王五")).show())

}

---

1.3 接口的定义

//TODO Kotlin语言中的接口
/*
*   1.接口里面的所有成员 和 接口本身 都是public open的，所以不用open，接口的特殊性
*   2.接口不能有主构造，反正就是没有构造
*   3.实现类不仅仅需要重写接口的函数 同时 也许哟重写接口的成员
* */
interface IUSB{
    var usbVersionInfo:String
    var usbInsertDevice:String
    fun insertUSB():String
}
//鼠标usb实现类
class Mouse (override var usbInsertDevice: String="USB3.0",
             override var usbVersionInfo: String="鼠标接入了USB接口"):IUSB{

    override fun insertUSB(): String {
        return "Mouse  $usbVersionInfo, 版本是：$usbInsertDevice"
    }

}

//键盘usb实现类
class KeyBoard (override var usbInsertDevice: String="USB3.1",
                override var usbVersionInfo: String="键盘接入了USB接口"):IUSB{
    override fun insertUSB(): String {
        return "KeyBoard  $usbVersionInfo, 版本是：$usbInsertDevice"
    }

}
fun main() {
    println(Mouse().insertUSB())
    println(KeyBoard().insertUSB())

}

---

1.4 抽象类

//TODO Kotlin语言中的抽象类
/*
*
* */
abstract class BaseActivity{
    fun onCreate(){
        setContentView(getLayoutID())
        getLayoutID()
        initView()
        initData()
        initXXX()
    }
    private fun setContentView(layoutID:Int)= println("加载【$layoutID】布局xml文件")

    abstract fun getLayoutID():Int
    abstract fun initView()
    abstract fun initData()
    abstract fun initXXX()
}
class MainActivity: BaseActivity() {
    override fun getLayoutID(): Int=123

    override fun initView()= println("做具体初始化view实现")

    override fun initData() =println("做具体初始化数据实现")
    override fun initXXX()=println("做具体初始化xxx实现")

    fun show(){
        super.onCreate()
    }
}
fun main() {
    var s = MainActivity()
    s.show()
}

1.5 泛型类

//TODO Kotlin语言中的泛型

class KtBase70<T> (private var objects: T){
    fun show()= println("万能输出器：$objects")
}
data class Student(var name:String,var age:Int,var sex:Char)
data class Teacher(var name:String,var age:Int,var sex:Char)

fun main() {
    val s1 = Student("学生1", 21, '男')
    val s2 = Student("学生2", 21, '女')
    val t1 = Teacher("老师1", 33, '男')
    val t2 = Teacher("老师2", 32, '女')

    KtBase70(s1).show()
    KtBase70(s2).show()
    KtBase70(t1).show()
    KtBase70(t2).show()

}

---

1.6 可变参数

vararg，通常是最后一个参数标记为vararg（可使用具名函数传值），只能有一个参数被标记为vararg，实际上是数组
可变参数在作为数组传递时需要使用伸展（spread）操作符（在数组前面加 *）

fun main() {
    // 虽然只有三个参数，但可以传入这么多
    show(1, "b", "c","c","c","c","c")
}

fun show(a: Int, b: String, vararg c: String) {
    println(a)
    println(b)
    hello(*c)
}

fun hello(vararg c: String) {
    c.forEach { println(it) }
}

---

1.7 OUT-协变

//生产者out T 协变
interface Producer<out T>{
    // out T  代表整个生产者类里面  整个T  只能被读取，不能被修改了
//    //不能被修改了（编译不通过）
//     fun change(item:T)

    //只能被读取
     fun read() : T
}
//消费者in T 逆变
interface Customer<in T>{
    //in  T  代表整个消费者里面  只能被修改,不能被读取
    //不能被读取了(编译不通过)
//    fun read():T
    fun change(item:T)

}
//生产者&消费者 T 默认情况下是不变的
interface ProducerAndCustomer<T>{
    //能被修改
    fun change(item:T)
    //能被读取
    fun read() : T

}
open class Animal //动物
open class Humanity :Animal()  //人类
open class Man :Humanity()   //男人
open class Woman:Humanity()  //女人

class ProducerClass1: Producer<Animal>{
    override fun read(): Animal {
        println("生产者 Animal")
        return Animal()
    }

}
class ProducerClass2: Producer<Humanity>{
    override fun read(): Humanity {
        println("生产者 Humanity")
        return Humanity()
    }

}
class ProducerClass3: Producer<Man>{
    override fun read(): Man {
        println("生产者 Man")
        return Man()
    }

}
class ProducerClass4: Producer<Woman>{
    override fun read(): Woman {
        println("生产者 Woman")
        return Woman()
    }

}
fun main() {
    val p1:Producer<Animal> = ProducerClass1()
    val p2:Producer<Animal> = ProducerClass2()
    val p3:Producer<Animal> = ProducerClass3()
    val p4:Producer<Animal> = ProducerClass4()
    p1.read();p2.read();p3.read();p4.read()
    //泛型默认情况下是,泛型的子类对象,不可以赋值给 泛型的父类对象
    //out:  泛型的子类对象,可以赋值给 泛型的父类对象
    //协变:  父类 泛型声明处   可以接收  子类 泛型具体处
}

---

1.8 IN-逆变

//TODO Kotlin语言中的in-逆变学习
/*
*
* */
class CustomerClass1: Customer<Animal>{
    override fun change(item: Animal) {
        println("消费者 Animal")
    }
}
class CustomerClass2: Customer<Humanity>{
    override fun change(item: Humanity) {
        println("消费者 Humanity")
    }
}
class CustomerClass3: Customer<Man>{
    override fun change(item: Man) {
        println("消费者 Man")
    }
}
class CustomerClass4: Customer<Woman>{
    override fun change(item: Woman) {
        println("消费者 Woman")
    }
}
fun main() {
    val p1: Customer<Man> =CustomerClass1()
    val p2: Customer<Woman> =CustomerClass2()

    //默认情况下:  泛型具体处的父类   是不可以赋值给  泛型声明处的子类
    //in:   泛型具体处的父类  是可以赋值给   泛型声明处的子类

    //逆变:  子类 泛型声明处    可以接收     父类 泛型具体处
    p1.change(Man())
    p2.change(Woman())
}

---