android开发之&android中的swift，kotlin中多姿多彩的类（六）

/**
 * 数据类
 */
data class Leaf(val size:String,val color:String,val shape:String,val vein:Int)

fun main(args: Array<String>) {
    val myleaf = Leaf("30","green","circle",57)
    val lsize = myleaf.size
    val lcolor = myleaf.color
    val lshape = myleaf.shape
    val lvein = myleaf.vein
    println("大小：${lsize}  颜色：${lcolor}   形状：${lshape}  叶脉数：${lvein}")

    val myleaf2 = Leaf("30","green","circle",30)
    val (size,color,shape,vein) = myleaf2
    println("大小：${size}  颜色：${color}   形状：${shape}  叶脉数：${vein}")
}

/**
 * 密封类
 */
open class Fruit()

class Apple:Fruit(){
    fun operate() = println("给妈妈吃")
}

class Banana:Fruit(){
    fun operate() = println("给爸爸吃")
}

class WaterMelon:Fruit(){
    fun operate() = println("自己吃")
}

fun operate(fruit: Fruit) = when (fruit){
    is Apple    ->      fruit.operate()
    is Banana   ->      fruit.operate()
    is WaterMelon->     fruit.operate()
    else        ->      null
}

//密封类实现上面demo
sealed class Fruit2{
    class Apple: Fruit2(){
        fun operate() = println("给妈妈吃")
    }
    class Banana:Fruit(){
        fun operate() = println("给爸爸吃")
    }

    class WaterMelon:Fruit(){
        fun operate() = println("自己吃")
    }
}
fun main(args: Array<String>) {
    val one_fruit = Banana()
    operate(one_fruit)

    val two_fruit = Fruit2.Banana()
    operate(one_fruit)
}

/**
 * 泛型
 */
class Container<T>(thing: T){
    val thing: T = thing
    fun printInformation() = println("This thing is ${thing}")
}

fun <T>one_int_container_say_hello(c:Container<T>){
    c.printInformation()
}

//泛型接口
interface Factory<T>{
    fun produce(ele:T)
}
class StringFactory:Factory<String>{
    override fun produce(ele: String) {
        println("produce ${ele}")
    }
}
class IntFactory:Factory<Int>{
    override fun produce(ele: Int) {
        println("produce ${ele}")
    }
}
class DoubleFactory:Factory<Double>{
    override fun produce(ele: Double) {
        println("produce ${ele}")
    }
}
class MyFactory<T>:Factory<T>{
    override fun produce(ele: T) {
        println("produce ${ele}")
    }
}

interface Factory2<out T>{
    fun produce():T
}
fun change(f:Factory2<String>){
    val facotry_any : Factory2<Any> = f
}


//计算器demo
interface ComputionInterface<T>{
    fun add(num1:T,num2:T)
    fun sub(num1:T,num2:T)
    fun mul(num1:T,num2:T)
    fun div(num1:T,num2:T)
}
class Compution<T>:ComputionInterface<T>{
    override fun add(num1: T, num2: T) {
//        val num = num1 + num2
//        println(num)
    }

    override fun sub(num1: T, num2: T) {
//        val num = num1 - num2
//        println(num)
    }

    override fun mul(num1: T, num2: T) {
//        val num = num1 * num2
//        println(num)
    }

    override fun div(num1: T, num2: T) {
//        val num = num1 / num2
//        println(num)
    }
}

fun main(args: Array<String>) {
    val c = Container<Int>(1)
    c.printInformation()

    val c1 = Container(1)
    one_int_container_say_hello(c1)
    val c2 = Container("hi")
    one_int_container_say_hello(c2)
}

/**
 * 嵌套类
 */
class Taohuan{
    val outcolor:String = "red"
    val size:Int = 20
    val shape:String = "circle"

    fun getshape():String{
        val shape = this@Taohuan.shape
        return shape
    }

    fun getshape2():String{
        val shape2 = this.shape
        return shape2
    }

    inner class jiangpin{
        val incolor:String = "blue"
        val size:Int = 15
        val shape:String = "rect"

        fun getoutsize():Int{
            val outsize = this@Taohuan.size
            return outsize
        }

        fun getinsize():Int{
            val insize = this@jiangpin.size
            return insize
        }

        fun getthissize():Int{
            val thissize = this.size
            return thissize
        }
    }
}
fun main(args: Array<String>) {
    val mytaohuan = Taohuan()
    val myjiangpin = Taohuan().jiangpin()
    println("外部类this@类名  ： ${mytaohuan.getshape()}")//circle
    println("外部类this       :  ${mytaohuan.getshape2()}")//circle
    println("内部类this@外部类名： ${myjiangpin.getoutsize()}")//20
    println("内部类this@内部类名：${myjiangpin.getinsize()}")//15
    println("内部类this        ：   ${myjiangpin.getthissize()}")//15
}

/**
 * 枚举类
 */
enum class Enumclass{
    enum1,enum2,enum3;
    fun functionA():Unit{
        println("枚举类的常量可以直接调用类里的方法")
    }
}

enum class Familier(val rank:Int){
    father(1),mother(2),son(3),daughter(4)
}

enum class F


enum class Familier2(var rank: Int){
    father(1),mother(3),son(2),daughter(4);

    override fun toString(): String {
        var str:String = "成员名称："+this.name + "成员排名："+rank + "\n"
        return str
    }
    fun favoritefood():Unit{
        when (this.name){
            "father"        ->      println("father likes apple \n")
            "mother"        ->      println("mother likes banana \n")
            "son"           ->      println("son likes watermelon \n")
            "daughter"      ->      println("daughter likes peach \n")
            else            ->      println("Familier2 do not have this person \n")
        }
    }
    fun action(){
        println("wo all like sports! \n")
    }
}
fun main(args: Array<String>) {
    Enumclass.enum1.functionA()
    println("话语权：\n父亲：${Familier.father.rank}  母亲：${Familier.mother.rank}"+"儿子：${Familier.son.rank}  女儿：${Familier.daughter.rank}")

    var a:Int = Familier.mother.compareTo(Familier.son)
    println("前者先声明，则返回 $a \n")                      //前者先声明，则返回-1
    var b:Int = Familier.daughter.compareTo(Familier.son)
    println("前者后声明，则返回 $b \n")                      //前者后声明，则返回1
    var c:Int = Familier.son.compareTo(Familier.son)
    println("两者相同则返回 $c \n")                        //两者相同返回0
    var d:Int = Familier.father.ordinal
    var e:Int = Familier.daughter.ordinal
    println("ordinal()函数从 $d 开始，到 $e 结束 \n")        //ordinal()函数从0开始，到3结束


    println("${Familier2.father.toString()}")
    Familier2.father.favoritefood()
    println("${Familier2.mother.toString()}")
    Familier2.mother.favoritefood()
    println("${Familier2.son.toString()}")
    Familier2.son.favoritefood()
    println("${Familier2.daughter.toString()}")
    Familier2.daughter.favoritefood()
    Familier2.daughter.action()

}

/**
 * 对象
 */
open class One(age:Int){
    var age: Int = age
}
class Two:One(age = 10){
    fun newaddfunction(){
        println("我是新增的成员！")
    }
}


interface Three{
    fun interfunction()
}
open class One2(age:Int){
    open var age:Int = age
    open fun classfunction(){
        println("我是类里的方法")
    }
}
fun main(args: Array<String>) {
    var two = Two()
    println("${two.age} \n")
    two.newaddfunction()

    var three = object :One(20){
        fun newaddfunction(){
            println("我是新增加的方法！")
        }
    }
    println("${three.age} \n")
    three.newaddfunction()

    var two2 = object : One2(20),Three {
        override fun interfunction() {
            println("在对象表达式中覆盖了接口的方法")
        }

        override var age: Int = 21
        override fun classfunction() {
            println("在对象表达式中覆盖了父类的方法")
        }
    }
    println("覆盖了父类的age属性：${two2.age}")
    two2.interfunction()
    two2.classfunction()
}

/**
 * 委托
 */
interface Shangji{
    fun getTask()
}
class Me(name:String):Shangji{
    var name = name
    override fun getTask() {
        println("上级布置的任务给${this.name},他要委托给别人")
    }
}
class AnotherOne(one:Shangji):Shangji by one


enum class Familier1(){
    father1,mother1,son1;
    fun favoritefood(){
        when (this.name){
            "father1"   ->  println("father1 likes apple")
            "mother1"   ->  println("mother1 likes banana")
            "son1"      ->  println("son1 likes watermelon")
            else        ->  println("Familier1 do not have this person")
        }
    }
}

interface Shangji2{
    fun getTask()
}
class Me2(name:String):Shangji2{
    var name = name
    override fun getTask() {
        println("帮忙写个程序")
    }
}
class AnotherOne2(one: Shangji2):Shangji2 by one{
    override fun getTask() {
        println("你这个太low了，我给你写个高大上的")
    }
}


//委托属性
class Queself(mynameSX:String){
    var mynameSX:String = mynameSX
    var weituoSx:String by AnotherClass()
}
class AnotherClass{
    operator fun getValue(duixiang:Any?,myshuxing:KProperty<*>):String{
        return "$duixiang 委托了 ${myshuxing.name} 属性给 ${this@AnotherClass}"
    }
    operator fun setValue(duixiang: Any?,myshuxing: KProperty<*>,value:String){
        println("$duixiang 的 ${myshuxing.name} 属性被我赋值为 $value")
    }
}

val LazySX:String by lazy {
    print("表达式")
    "结果1"
}
class Watchable{
    var value: String by Delegates.observable("初始值"){
        prop,old,new        ->
        println("旧值：$old    -> 新值：$new")
    }
}


class Count{
    var num: Int by Delegates.observable(1){
        prop,old,new ->
        var number = old * new
        println("简单算术：$old * $new = $number")
    }
}
fun main(args: Array<String>) {
    val one = Me("小明")
    AnotherOne(one).getTask()

    Familier1.father1.favoritefood()
    Familier1.mother1.favoritefood()
    Familier1.son1.favoritefood()

    var one2 = Me2("小明")
    AnotherOne2(one2).getTask()

    //委托属性
    val example = Queself("小红")
    println("未被委托的属性：${example.mynameSX}")//未被委托的属性：小红
    println(example.weituoSx)                   //Quesrlf@4783da3f委托weituoSX属性给AnotherClass@378fdlac
    example.weituoSx = "123456"                 //Quesrlf@4783da3f的weituoSX属性被我赋值为123456
    println(example.weituoSx)                   //Quesrlf@4783da3f委托了weituoSX属性给AnotherClass@378fdlac


    var k = 1
    while (k<5){
        println("${LazySX}")
        k++
    }

    val exampl = Watchable()
    exampl.value = "给一个新值"
    exampl.value = "给另一个新值"

    val exam = Count()
    var i = 2
    while (i < 10){
        exam.num = i
        i++
    }
}