Kotlin 第四章：Kotlin 基础之包、控制流、返回与跳转

Kotlin 第四章：Kotlin 基础之包、控制流、返回与跳转

上一篇文章介绍了 Kotlin 基础中的基本类型，这篇文章，咱们一起来学习一下 Kotlin 的基础知识之包、控制流、返回与跳转。

包

在 Kotlin 中与在 Java 中一样，源文件也是以包的声明开始的。

package foo.bar

fun bza() {}

class Goo {}

//...

源文件的所有内容(比如类和函数)都被包声明包括。因此在上面的例子中， bza() 的全名应该是 foo.bar.bza ，Goo 的全名是 foo.bar.Goo。

如果没有指定包名，那这个文件的内容就从属于没有名字的 "default" 包。

导入

除了模块中默认导入的包，每个文件都可以有它自己的导入指令。导入语法的声明在grammar中描述。

我们可以导入一个单独的名字，比如下面这样：

import foo.Bar //Bar 现在可以不用条件就可以使用

或者范围内的所有可用的内容 (包，类，对象，等等):

import foo.*/ /foo 中的所有都可以使用

如果命名有冲突，我们可以使用 as 关键字局部重命名解决冲突

import foo.Bar // Bar 可以使用
import bar.Bar as bBar // bBar 代表 'bar.Bar'

与 Java 不同，Kotlin 没有单独的 “import static” 语法;
所有这些声明都使用常规 import 关键字导入。

可见性和包嵌套

如果最顶的声明标注为 private , 那么它是自己对应包私有。如果包内有私有的属性或方法，那它对所有的子包是可见的。

注意包外的的成员是默认不导入的，比如在导入 foo.bar 后我们不能获得 foo 的成员

控制流

在 Kotlin 中控制流有四种，分别是：if、when、for、while。

if 表达式

在 Kotlin 中，if 是表达式，比如它可以返回一个值（true 或者是 false）。而且在 Kotlin 中是没有三目运算符的。

//传统用法
var max = a
if (a < b)
    max = b

//带 else 
var max: Int
if (a > b)
    max = a
else
    max = b

//作为表达式
val max = if (a > b) a else b

if 分支可以作为块，最后一个表达是是该块的值：

val max = if (a > b){
    print("Choose a")
    a
}
else{
    print("Choose b")
    b
}

如果 if 表达式只有一个分支，或者分支的结果是 Unit , 它的值就是 Unit 。

如果使用 if 作为一个表达式，表达式需要有一个 else 分支。

val max = if (a > b) a // 这样写是错误的
val max = if (a > b) a else b // 这样才是正确的

when 表达式

在第二章基本语法的时候，简单的提过一下 when 表达式。Kotlin 中的 when 表达式 类似于 Java 中的 switch 表达式，但是与 Java 中的switch 表达式又有所不同。最简单的用法如下：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { //Note the block
        print("x is neither 1 nor 2")
    }
}

when 会对所有的分支进行检查直到有一个条件满足。在其它分支都不匹配的时候默认匹配 else 分支。如果把 when 做为表达式的话 else 分支是强制的，除非编译器可以提供所有覆盖所有可能的分支条件。这个地方与 Java 中 switch 的 default 有所区别。

如果有分支可以用同样的方式处理的话，分支条件可以连在一起：

when (x) {
    0,1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

可以用任意表达式作为分支的条件

when (x) {
    parseInt(s) -> print("s encode x")
    else -> print("s does not encode x")
}

甚至可以用 in 或者 !in 检查值是否值在一个集合中：

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

也可以用 is 或者 !is 来判断值是否是某个类型。注意，由于 Kotlin 可以自动判断变量的类型，所以你可以不用另外的检查就可以使用相应的属性或方法。

val hasPrefix = when (x) {
    is String -> x.startsWith("prefix")
    else -> false
}

when 也可以用来代替 if-else if。如果没有任何参数提供，那么分支的条件就是简单的布尔表达式，当条件为真时执行相应的分支：

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

至于 Kotlin 的 when 语句好用还是 Java 的 switch 好用，全看个人了感觉了。

for 循环

for 循环在第二章基本语法中也已经说过了，而且说得也是比较常用的内容了，这里就只是简单的提一下，不在多做赘述。

for 循环通过任何提供的迭代器进行迭代。语法是下面这样的：

for (item in collection)
    print(item)

内容可以是一个语句块

for (item: Int in ints){
    //...
}

像之前提到的， for 可以对任何提供的迭代器进行迭代，比如：

has an instance- or extension-function iterator(), whose return type
has an instance- or extension-function next(), and
has an instance- or extension-function hasNext() that
returns Boolean.

如果你想通过 list 或者 array 的索引进行迭代，你可以这样做：

for (i in array.indices)
    print(array[i])

while 循环

在 Kotlin 中 while 和 do...while 与 Java 的一样，有一个区别是，语句块里面的变量在外面是可见的。

while (x > 0) {
    x--
}

do {
    val y = retrieveData()
} while (y != null) // y 在这是可见的

返回与跳转

Kotlin 中与 Java 一样，支持三种跳转操作符：return、break、continue。

return、break 结束最近的闭合循环 continue 跳到最近的闭合循环的下一次循环

break 和 continue 标签

在 Kotlin 中表达式可以添加标签。标签通过 @ 结尾来表示，比如：abc@，fooBar@ 都是有效的。使用标签语法只需像这样：

loop@ for (i in 1..100){ // loop@就是标签
    //...
}

使用 break 跳转到标签处，跳出循环

loop@ for (i in 1..10) {
    for (j in i..10) {
        if (j == 5) 
            break@loop // 跳出循环
        Log.e(Tag, j.toString()) // j 为5的时候跳出了循环，只打印1、2、3、4
    }
}

使用 continue 跳转到标签处，进行下一次循环

loop@ for (i in 1..10) {
    for (j in i..10) {
        if (j == 5) 
            continue@loop // 跳出本次循环，进行下一次循环
        Log.e(Tag, j.toString()) // j 为5的时候跳出了循环，所有不会打印5
    }
}

return 标签

return 允许我们返回到外层函数。最重要的例子就是从字面函数中返回。

fun foo() {
    ints.forEach {
        if (it == 0) return // 跳出forEach
        print(it)
    }
}

return 表达式返回到最近的闭合函数，比如 foo (注意这样非局部返回仅仅可以在内联函数中使用)。如果我们需要从一个字面函数返回可以使用标签修饰 return :

fun foo() {
    ints.forEach lit@ {
        if (it ==0) return＠lit
        // 这样就不会return到foo函数，而是return到标签处的forEach函数
        print(it)
    }
}

现在它仅仅从字面函数中返回。经常用一种更方便的含蓄的标签：比如用和传入的 Lambda 表达式名字相同的标签。

fun foo() {
    ints.forEach {
        if (it == 0) return@forEach
        // 与上面一样，return到标签处的forEach函数
        print(it)
    }
}

另外，我们可以用函数表达式替代字面函数。在函数表达式中使用 return 语句可以从函数表达式中返回。

fun foo() {
    ints.forEach(fun(value:  Int){
        if (value == 0) return
        print(value)
    })
}

当返回一个值的时候，如 return@a 1，表示在标签 @a 处返回 1，而不是返回带标签的表达式@a 1。

后记

基本类型到这里可以暂时告一段落，可能有错误或者不太全面，请各位看官提出宝贵的意见。

参考

Kotlin中文文档

叫我旺仔的简书