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

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

包

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

package foo.barfun 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 = aif (a < b)    max = b//带 else var max: Intif (a > b)    max = aelse    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中文文档

叫我旺仔的简书