kotlin学习笔记（二）

一、数据初始化

var可使用laterinit来延迟初始化，需后期再初始化。

val使用 by lazy 后接初始化的表达式。

class B {

}

class A {

    var num = 0

    lateinit var name: String//生成A的时候，不初始化，需要初始化

    lateinit var b: B//生成A的时候，不初始化，需要初始化

    val c: B  by lazy {

        println("c init")

        B()

    }//生成A的时候 不初始化，调用c的时候初始化

    var person: String?=null//不建议使用这种方式初始化，后期每次都需做！！判断

}

fun main(args: Array<String>) {

    println("start")

    val a =A()

    println("init a")

    a.c

}

二、Lambda

opFun使用lambda

class Operator(op: String) {

    val opFun: (left: Double, right: Double) -> Double

    init {

        opFun = when (op) {

            "+" -> { l, r -> l + r }

            "-" -> { l, r -> l - r }

            "*" -> { l, r -> l * r }

            "/" -> { l, r -> l / r }

            "%" -> { l, r -> l % r }

            else -> {

                throw  UnsupportedOperationException(op)

            }

        }

    }

    fun apply(left: Double, right: Double): Double {

        return opFun(left, right)

    }

}

lambda表达式返回得值为方法体中的最后一行。

方法接受的参数最后一个为Lambda表达式，可将表达式移出去，参数只有一个Lambda，调用时小括号可省略。

Lambda只有一个参数的时候，默认为it。

forEach后可直接：：println或println（it）

fun main(args: Array<String>) {

    println(lambda("flexible"))

    args.forEach { print(it) }

    args.forEach({ })

    lambdaTest { int: Int ->

        int

    }

}

val sum = { arg1: Int, arg2: Int ->

    arg1 + arg2

}

val lambda = { data: String ->

    println(data)

    4

}

fun lambdaTest(action: (Int) -> Int) {

  print(  action(4))

}