学习kotlin系列之八（开发实用1）

1、中缀表达式

中缀表达式：让代码更加简洁易懂
说明：使用的条件 DSL语言
1）必须是成员函数或扩展函数；
2）必须只有一个参数；
3）参数不能是可变参数或者默认参数。

fun main(args: Array<String>) {
    val 张三 = Person()
    张三 sayHelloTo "李四"
    //自定义操作符
}

class Person {
    infix fun sayHelloTo(name: String) {//使用关键字infix
        println("你好,$name")
    }
}

2、委托

1）类委托

类委托：就是经验总结出来的

/**
*说明：大头儿子和小头爸爸的例子
*/
fun main(args: Array<String>) {
    val smallHeadFather = SmallHeadFather()
    smallHeadFather.wash()
}

//洗碗的能力
interface WashPower {
    //洗碗行为
    fun wash()
}

class BigHeadSon : WashPower {
    override fun wash() {
        println("小头儿子洗的碗")
    }
}

class SmallHeadFather : WashPower by BigHeadSon()

2）类委托扩展

fun main(args: Array<String>) {
//    val smallHeadFather = SmallHeadFather(BigHeadSon())
    val smallHeadFather1 = SmallHeadFather(SmallHeadSon())
    smallHeadFather1.wash()

}

//洗碗的能力
interface WashPower {
    //洗碗行为
    fun wash()
}

class BigHeadSon : WashPower {
    override fun wash() {
        println("小头儿子洗的碗")
    }
}

class SmallHeadSon : WashPower {
    override fun wash() {
        println("大头儿子洗的碗")
    }
}

//扩展性比较强，只要有洗碗能力的人都可以放进去
class SmallHeadFather(var washPower: WashPower) : WashPower by washPower {
    override fun wash() {

        washPower.wash()
    }
}

3）属性委托

/**
 * 说明：大头儿的压岁钱委托给了围裙妈妈
 */
fun main(args: Array<String>) {
    val bigHeadSon = BigHeadSon()
    bigHeadSon.压岁钱 = 200
    println("${bigHeadSon.压岁钱}")
}


class BigHeadSon {
    //存钱罐
    var 压岁钱: Int by Mother()
}

class Mother {


    operator fun getValue(bigHeadSon: BigHeadSon, property: KProperty<*>): Int {
        return 儿子的压岁钱
    }

    operator fun setValue(bigHeadSon: BigHeadSon, property: KProperty<*>, i: Int) {
        儿子的压岁钱 += i
    }

    var 儿子的压岁钱 = 0
    var 自己的小金库 = 0
}

3、惰性和延迟加载

1）惰性加载

惰性加载：1）用的时候再加载 2）懒加载
说明：字段必须是不变的val
by lazy放到成员变量中 可以单独存在
by lazy返回值就是最后一行
by lazy线程安全

val name1: String by lazy {
    println("初始化了")
    "张三"
}

fun main(args: Array<String>) {
    println(name1)
    println(name1)
}
//结果
初始化了
张三
张三

2）延迟加载

lateint 延迟加载：1）用的时候再赋值 2）不复制运行报错；
说明：使用var修饰
二者区别：
（1）、lazy和lateinit 都可以单独使用或者放到成员变量中使用；
（2）、by lazy 知道具体值 用的时候再加载；
（3）、lateinit 不知道具体的值 后面再估值；
（4）、bu lazy 变量必须通过val修饰 lateinit需要通过var修饰。

fun main(args: Array<String>) {
    var person = Person()
    person.setName("呵呵")
    println(person.name1)
}

class Person {
    //不确定 后面可能用的时候才会赋值 不知道具体是什么
    lateinit var name1: String
    fun setName(name: String) {
        this.name1 = name
    }
}

4、扩展函数

扩展函数：
1）不改变已有类的情况下，为类添加新的函数
2）扩展函数主要是代替java的util类

fun main(args: Array<String>) {
val str:String?=null
    val myIsEmpty:Boolean? = str?.myIsEmpty()
    println(myIsEmpty)
    println(str.myIsEmptyByNull())
    val son=Son()
    son.sayHello()
}
/**
 * 扩展函数
 * 1、String类扩展 fun String.扩展函数名
 * 2、扩展函数可以访问当前对象里面的字段和方法
 */
//扩展的非空类型的String 可不可扩展可控类型的对象
fun String.myIsEmpty():Boolean{
    return this==null||this.length==0
}
fun String?.myIsEmptyByNull():Boolean{
    return this==null||this.length==0
}
//子类的父类也是可以有扩展函数的
fun Father.sayHello(){
    println("父类打招呼")
}
open class Father{
//    fun say(){
//        println("你好")
//    }
}
class Son:hunter.com.day04.Father(){

}