kotlin学习笔记（二）

来源：互联网发布：网络专供款烟机编辑：程序博客网时间：2024/06/04 19:36

一、数据初始化

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))
}

三、函数（fun）

class Men(character: String, looks: String, voice: String) {
    fun sing() {
        println("唱歌!")
    }

    fun dance() {
        println("跳舞!")
    }
}

fun main(args: Array<String>) {
    val men = Men("内向", "帅气", "低沉")
    men.dance()
    men.sing()
}

四、表达式

When表达式

const val USER_NAME = "kotlin"
const val USER_PWD = "jetbrains"

const val ADMIN_NAME = "admin"
const val ADMIN_PWD = "admin"

const val DEBUG = 0
const val USER = 1
fun main(args: Array<String>) {
    var state = 1
    if (state == DEBUG) {
        state = DEBUG
    } else {
        state = USER
    }
    println("请输入用户名")
    val name = readLine()
    println("请输入密码|")
    val pwd = readLine()
    if (state == USER && name == ADMIN_NAME && pwd == ADMIN_PWD) {
        println("admin登录成功")
    } else if (name == USER_NAME && pwd == USER_PWD) {
        println("登录成功")
    } else {
        println("账号或密码错误")
    }

    val x = 3
    when (x) {
        is Int -> println("Hello $x")
        in 1..100 -> println("$x is  in 100")
        !in 1..100 -> println("$x is not in 1..100")
        args[0].toInt() -> println("flexible")
    }

中缀表达式：可重新定义基本运算符，可重载。也可自定义函数，使函数无需 class. 调用。

class Complex(var real: Double, var imaginary: Double) {
    operator fun plus(otehr: Complex): Complex {
        return Complex(real + otehr.real, imaginary + otehr.imaginary)
    }

    operator fun plus(int: Int): Complex {
        return Complex(real + int, imaginary +int)
    }

    operator fun invoke(): Double {
        return 3.0
    }

    override fun toString(): String {
        return "$real +$imaginary"
    }
}


class Book {
    infix fun on(any: Any): Boolean {
        return false
    }
}

class Desk

fun main(args: Array<String>) {
    val c1 = Complex(4.0, 5.0)
    val c2 = Complex(4.0, 5.0)
    println(c1 + c2)
    println(c1())
    if (Book() on Desk()) {

    }
}

五、简单计数器

fun main(args: Array<String>) {
    println("请输入算式 例如：3 + 4")
    while (true) {
        try {
            val input = readLine() ?: break
            val split = input.split(" ")
            if (split.size < 3) {
                throw IllegalArgumentException("zz")
            }
            val left = split[0].toDouble()
            val op = split[1]
            val right = split[2].toDouble()
            println("$left $op $right = ${Operator(op).apply(left, right)}")

        } catch (e: NumberFormatException) {
            println("您确定输入的是数字嘛？")
        } catch (e: IllegalArgumentException) {
            println("您确定输入是三个参数并且用空格分割？")
        } catch (e: Exception) {

        }
        println("在来一次！")
        val cmd = readLine()
        if (cmd == null || cmd.toLowerCase() != "y") {
            break
        }
    }
    println("感谢使用！")
}

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)
    }

}

一、数据初始化