kotlin-10

一、异常

Kotlin 中异常处理的基本形式和 Java 类似

fun compute(index: Int): Boolean {
    if (index !in 0..10) {
        throw IllegalArgumentException("参数错误")
    }
    return true
}

和 Java 不同的是，Kotlin 中 throw 结构是一个表达式，可以作为另一个表达式的一部分来使用

例如下面这个例子，如果条件不满足，则将抛出异常，从而导致 status 变量也不会初始化

val status = if (index in 0..10) index else throw IllegalArgumentException("参数错误")

此外，在 Java 中对于受检异常必须显式地处理，通过 try/catch 语句捕获异常或者是抛给其调用者来处理。而 Kotlin 不区分受检异常和未受检异常，不用指定函数抛出的异常，可以处理也可以不处理异常

在 Kotlin 中，try 关键字引入了一个表达式，从而可以把表达式的值赋给一个变量。如果一个 try 代码块执行正常，代码块中最后一个表达式就是结果，如果捕获到了一个异常，则相应 catch 代码块中最后一个表达式就是结果

看以下例子，如果 try 表达式包裹的表达式会抛出异常，则返回值为 null ，否则为 true

fun main(args: Array<String>) {
    compute(5)   //fun end : true
    compute(100) //fun end : null
}

fun compute(index: Int) {
    val status = try {
        if (index in 0..10) true else throw IllegalArgumentException("参数错误")
    } catch (e: Exception) {
        null
    }
    println("fun end : " + status)
}

但是，如果在 catch 语句中使用 return 结束了 compute 函数，则没有任何输出

fun main(args: Array<String>) {
    compute(5)   //fun end : true
    compute(100) //没有任何输出
}

fun compute(index: Int) {
    val status = try {
        if (index in 0..10) true else throw IllegalArgumentException("参数错误")
    } catch (e: Exception) {
        return
    }
    println("fun end : " + status)
}

最近在写需求的时候，发现构造函数这块，出了问题，所以总结下这个地方

二、命名参数、默认参数值、可变参数

2.1、命名参数

为了增强代码的可读性，Kotlin 允许我们使用命名参数，即在调用某函数的时候，可以将函数参数名一起标明，从而明确地表达该参数的含义与作用，但是在指定了一个参数的名称后，之后的所有参数都需要标明名称

fun main(args: Array<String>) {
    //错误，在指定了一个参数的名称后，之后的所有参数都需要标明名称
    //compute(index = 110, "leavesC")
    compute(index = 120, value = "leavesC")
    compute(130, value = "leavesC")

}

fun compute(index: Int, value: String) {

}

2.2、默认参数值

可以在声明函数的时候指定参数的默认值，从而避免创建重载的函数

fun main(args: Array<String>) {
    compute(24)
    compute(24, "leavesC")
}

fun compute(age: Int, name: String = "leavesC") {

}

对于以上这个例子，如果按照常规的调用语法时，必须按照函数声明定义的参数顺序来给定参数，可以省略的只有排在末尾的参数

fun main(args: Array<String>) {
    //错误，不能省略参数 name
    //compute(24)
    //compute(24,100)
    //可以省略参数 value
    compute("leavesC", 24)
}

fun compute(name: String = "leavesC", age: Int, value: Int = 100) {

}

如果使用命名参数，可以省略任何有默认值的参数，而且也可以按照任意顺序传入需要的参数

fun main(args: Array<String>) {
    compute(age = 24)
    compute(age = 24, name = "leavesC")
    compute(age = 24, value = 90, name = "leavesC")
    compute(value = 90, age = 24, name = "leavesC")
}

fun compute(name: String = "leavesC", age: Int, value: Int = 100) {

}

2.3、可变参数

可变参数可以让我们把任意个数的参数打包到数组中传给函数，Kotlin 的语法相比 Java 有所不同，改为通过使用 varage 关键字声明可变参数

例如，以下的几种函数调用方式都是正确的

fun main(args: Array<String>) {
    compute()
    compute("leavesC")
    compute("leavesC", "叶应是叶")
    compute("leavesC", "叶应是叶", "叶")
}

fun compute(vararg name: String) {
    name.forEach { println(it) }
}

在 Java 中，可以直接将数组传递给可变参数，而 Kotlin 要求显式地解包数组，以便每个数组元素在函数中能够作为单独的参数来调用，这个功能被称为展开运算符，使用方式就是在数组参数前加一个 *

fun main(args: Array<String>) {
    val names = arrayOf("leavesC", "叶应是叶", "叶")
    compute(*names)
}

fun compute(vararg name: String) {
    name.forEach { println(it) }
}

2.4、局部函数

Kotlin 支持在函数中嵌套函数，被嵌套的函数称为局部函数

fun main(args: Array<String>) {
    compute("leavesC", "country")
}

fun compute(name: String, country: String) {
    fun check(string: String) {
        if (string.isEmpty()) {
            throw IllegalArgumentException("参数错误")
        }
    }
    check(name)
    check(country)
}