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) {
        al 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++    
    }
}