Kotlin笔记（一）

属性

//常量，只能写于方法之外，编译时就已经确定
//双shift输入show kotlin bytecode 查看字节码文件
const val MAX = 100

fun main() {
    //完整变量定义
    var str:String = "Hello world"
    println(str)
    //类型推断
    var str2 = "Hello"
    println(str2)
    //val表示只读 var表示后续可变
    var str3 = "A"
    str3 = "AA"
    val str4 = "B"
    println(str3)
    println(str4)
    println(MAX)
    //kotlin编写只提供引用类型，不过字节码会将其转化为基本类型
    val age:Int = 12
}

条件语句

fun main() {
    val age = 1
    //range条件语句
    //表示 age>=0 && age <=3
    if (age in 0..3) {
        println("in 0..3")
    }
    //表示 age<0 && age >3
    if (age !in 0..3) {
        println("!in 0..3")
    }
    //when条件语句
    val a = when(age) {
        0 -> "0"
        1 -> "1"
        2 -> "2"
        3 -> "3"
        4 -> "4"
        else -> "-1"
    }
    println(a)

    //String模板拼接
    val name1 = "小明"
    val name2 = "小红"
    println("${name1}和${name2}是好朋友")
    val name3 = "小刚"
    val flag = false
    println("${name1}和${if(flag) name2 else name3}是好朋友")
}

函数

fun main() {
    println(getResult(3))
    println(getResult2(3))
    //具名参数调用，指定参数名字和值，顺序可错位
    println(getResult2(i2=2, i=1))
    //没有返回值的方法返回Unit类型
    println(noResult())
    //系统TODO方法抛异常，返回的是Nothing类型
//    TODO("123")
    //调用反引号方法
    ` *123^ `()
}

//方法，修饰符默认public
private fun getResult(i:Int) : String {
    return "result=${i}"
}
//i2为缺省参数，可不传，默认为5
private fun getResult2(i:Int, i2:Int = 5) : String {
    return "result=${i + i2*10}"
}
//无返回值方法
private fun noResult() {
}

//反引号（键盘左上角）带符号的方法
fun ` *123^ `() {
    println("反引号方法")
}

匿名函数

fun main() {
    //无参匿名函数声明
    val fun0 : () -> String
    //无参匿名函数赋值
    fun0 = {
        val str = "无参匿名函数"
        //匿名函数最后一行为返回值，不用return
        str
    }
    println(fun0())

    //一个参数匿名函数
    val fun1 : (String) -> String = { name ->
        val str = "一个参数匿名函数"
        "${str}参数为：${name}"
    }
    println(fun1("kevin"))
    //一个参数匿名函数可以省略 name -> 系统自动使用it代替参数
    val fun11 : (String) -> String = {
        val str = "一个参数匿名函数"
        "${str}参数为：${it}"
    }
    println(fun11("kevin11"))

    //两个参数匿名函数
    val fun2 : (String, String) -> Unit = { name1, name2 ->
        println("两个参数匿名函数参数为${name1}和${name2}")
    }
    fun2("kevin", "peter")

    //无参匿名函数的类型推断
    val funT0 = {
        val str = "无参匿名函数类型推断"
        str
    }
    println(funT0())
    //一个参数匿名函数的类型推断
    val funT1 = { name:String ->
        val str = "一个参数匿名函数类型推断"
        "${str}参数为：${name}"
    }
    println(funT1("kevin"))
    //两个参数匿名函数的类型推断
    val funT2 = { name1:String, name2:String ->
        val str = "两个参数匿名函数类型推断"
        "${str}参数为：${name1}和${name2}"
    }
    println(funT2("kevin", "peter"))
}

函数简化

fun main() {
    val time = (1..12).random()
    execute("小明", time, { name:String, time:Int ->
        val str = "${name}在下午${time}点打球"
        str
    })
    //末尾参数可置于小括号外
    execute("小明", time) { name:String, time:Int ->
        val str = "${name}在下午${time}点打球"
        str
    }
    //唯一参数可省略小括号
    execute { name:String, time:Int ->
        val str = "${name}在下午${time}点打球"
        str
    }
    //使用具名函数的引用
    execute("a", 4, ::get123)
}

private fun get123(name: String, time: Int) : String {
    return "123"
}

private fun execute(name:String = "小刚", time:Int = 5, getStr:(String, Int)->String) {
    println(getStr(name, time))
}

函数闭包

fun main() {
    //函数返回值为函数
    val funAddOne = getFun()
    println(funAddOne(4))

    //返回的方法中使用上级方法的参数称之为闭包
    val funAddTwe = getFun2(4)
    println(funAddTwe())
}

private fun getFun() : (Int) -> String {
    return {
        (it+1).toString()
    }
}

private fun getFun2(a:Int) : () -> String {
    return {
        (a+2).toString()
    }
}

Kotlin的空安全

fun main() {
    //可空类型
    var a:String? = "aaa"
//    a = null
    println(a)
    //安全调用操作符?. ，加问号当为空的时候跳过此函数
    println(a?.capitalize())
    //带let的安全调用，不为null走后面的代码，尾句为返回值
    val b = a?.let {
        if (it.isNotBlank()) {
            it
        } else {
            "a is empty"
        }
    }
    println(b)
    //安全调用支持函数的链式调用
    val c = a?.capitalize()?.plus("ccc")
    println(c)
}

fun main() {
    var str:String? = "aaa"
//    str = null
    //非空断言操作符!!. ，会引发KotlinNullPointerException
//    println(str!!.capitalize())
    //空合并操作符?: ，符号前面不为空返回符号前面，为空返回符号后面
    val str2 = str ?: "bbb"
    println(str2)
    //安全调用与合并混合使用，str为空返回后面，否则返回前面的执行结果
    val str3 = str?.let { it.capitalize() } ?: "str is null"
    println(str3)
}

异常

fun main() {
    var num:Int? = null
    try {
        //抛出自定义异常
        num = num ?: throw MyException()
        println(num!!.plus(1))
    } catch (e : MyException) {
        e.printStackTrace()
    }
    println("捕获异常")
}

class MyException : IllegalArgumentException("未知异常")

系统判断异常函数

fun main() {
    val a:Int? = null
    //如果参数为null，会抛出第二个参数的返回值的IllegalStateException
    checkNotNull(a, {
        "a is null"
    })
    val b = false
    //如果参数为false，会抛出第二个参数的返回值的IllegalArgumentException
    require(b, {
        "b is false"
    })
    //如果参数为null，会抛出第二个参数的返回值的IllegalArgumentException
    requireNotNull(a, {
        "a is null"
    })
}