Kotlin实战02 — Kotlin基础

96
tigershin
2017.07.19 14:22* 字数 8258

这章将讲述

  • 声明函数、变量、类、枚举和属性
  • Kotlin的控制结构
  • 智能强转
  • 抛和处理异常

1 基本元素: 函数和变量

Kotlin的两大元素:函数和变量。你将明白,你可以省略类型声明,还有鼓励你使用不变而不是可变的数据。

1.1 Hello, world!

让我们以一个经典的例子开始:打印“Hello, world!”,在Kotlin中,你只需要一个函数:

fun main(args: Array<String>) { 
    println("Hello, world!") 
}

在这段简短的代码中,我们可以观察到什么该语言的什么部分和特点呢?请看下面的列表:

  • fun关键词用来声明一个函数
  • 参数类型现在参数名字的后面。同样适用于变量声明
  • 函数可以在文件的最上层中声明;你没必要把它放到一个类中
  • 数列仅仅是类。不像Java,Kotlin没有特定的声明数组的语法。
  • 用println,而不是System.out.println。Kotlin标准库提供了很多标准Java库函数的包装,这有更简洁的语法。println就是其中之一。
  • 在一行的最后省略了分号,就像在其他的语言。

1.2 函数

如果函数有返回类型,在函数参数后面加冒号和返回类型:

fun max(a: Int, b: Int): Int { 
    return if (a > b) a else b 
}
println(max(1, 2)) //2

注意,在Kotlin中if是个有返回值的表达式。类似于Java中的三目运算符(a > b)? a : b

语句(statement)和表达式(expression)

在Kotlin中,if是个表达式,而不是一个语句。语句和表达式的区别在于,表达式是一个值,可以被用作另外表达式的一部分;而语句总是一个包含它的代码块内的顶层元素,没有自己的值。在Java中,所有的控制结构都是语句,但是在Kotlin中,大部分控制结构,除了循环(for , do和do/while),是表达式。联合控制结构和其他的表达式,可以让你简洁表达许多通常的模式。

另外一方面,在Java中赋值是表达式,但是在Kotlin中变成了语句。这有效避免了比较和赋值之间的混淆,这个混淆也是错误的一个来源。

表达式主体
进一步可以简化前面函数,因为函数体只含有单个语句,你可以用表达式来作为整个函数体,移除花括号和返回语句:

fun max(a: Int, b: Int): Int = if (a > b) a else b

如果用花括号来表达函数主体,我们叫这个函数为代码块体(block body),如果直接返回表达式,我们叫它为表达式体(expression body)。

INTELLIJ IDEA提示 IntelliJ IDEA提供了在两种不同函数风格“Convert to expression body”和 “Convert to block body”之间的转换

表达式体的函数在Kotlin代码中很常见,这个风格不止用在一行函数,也用在对单一和更加复杂的表达式求值,比如if,when和try。我们进一步省略返回类型:

fun max(a: Int, b: Int) = if (a > b) a else b

为什么函数没有返回类型的声明呢?Kotlin不是一个静态语言,要求每个表达式在编译阶段都有类型吗?事实上,每个变量和每个表达式都有类型,每个函数也有返回类型。但是对于表达式体的函数,编译器可以分析作为函数体的表达式,用它的类型作为返回类型,即使没有显示的写出来。分析的这个类型通常叫类型推导(type inference)。

注意,省略返回类型仅仅在表达试体的函数中允许。有代码块体的有返回值的函数,你必须指明返回类型和显示的返回语句。这是个有意的抉择。实际中的函数通常非常长,可能包含很多返回语句,有显示的返回类型和语句可以帮助你快速的知道什么被返回。

1.3 变量

在Java中,你用类型声明变量。但是在Kotlin中,你可以也可以不把类型放到变量名后面。省略类型的声明如下

val question = "The Ultimate Question of Life, the Universe, and Everything"
val answer = 42

或者你显示的指明

val answer: Int = 42

如果你要浮点型的常量,可以推导为Double

val yearsToCompute = 7.5e6//7.5X10^6 = 7500000.0

可变和不可变量

  • val(来源于value)--- 不变的引用。一旦声明为val的量初始化后,不能够重新赋值。对应于Java里面的final变量
  • var(来源于variable)--- 可变的引用。变量的值可以改变。对应于Java里面的正常的变量(非final)

通常,尽量声明所有的变量为val关键词。只有有需要的时候,才变为val。用不可变的引用、不可变的实例和函数,没有副作用,使得你的代码更像函数式的风格。val变量只能在代码块中初始化有且仅有一次。但是可以根据不同的情况,用不同的值来初始化,如果编译器能够保证仅有一个初始化语句执行:

val message: String
if (canPerformOperation()) {
    message = "Success"
    // ... perform the operation } 
else {
    message = "Failed" 
}

注意,val引用自己是不可变的,但是,他指向的实例是可以改变的。比如,下面的代码是完全有效的:

val languages = arrayListOf("Java") //声明不可变的引用
languages.add("Kotlin")//改变引用指向的实例

尽管var关键词允许变量改变他的值,但是它的类型是确定的:

var answer = 42 
answer = "no answer"//编译错误:类型不匹配

如果你想在变量里面存储一个不匹配的类型的值,你必须转换或者协变这个值到正确的类型。

1.4 更容易的字符串格式化:字符串模板

这个部分开始的“Hello World”例子,我们进一步这个惯例,用Kotlin的方式,通过名字来问候。

fun main(args: Array<String>) { 
    //打印“Hello,Kotlin”,如果输入参数为Bob,则打印“Hello,Bob”
    val name = if (args.size > 0) args[0] else "Kotlin" 
    println("Hello, $name!") 
}

这个例子引进了一个功能叫字符串模板(string templates)。和其他脚本语言一样,Kotlin允许在字符串字面量中,通过$字符放在变量名前面,引用本地变量。这个同Java中的字符串连接("Hello, " + name + "!"), 但是更加紧凑和有效率(注:都是创建StringBuilder,添加常量部分和变量值,Java虚拟机有优化)。

如果你引用一个不存在的本地变量,因为表达式会静态检查,这些代码会编译不成功。如果你想在字符串中包含$符号,用println("\$x")换码,打印出$x,而不是把x翻译为一个变量的引用。

不限于一个简单的变量名,你也可以用更加复杂的表达式,仅仅只要在表达式括上花括号:

fun main(args: Array<String>) { 
    //用${}插入args数组的第一个元素
    if (args.size > 0) { println("Hello, ${args[0]}!") } 
}

你也可以双引号内陷双引号,只要他们是在同一个表达式:

fun main(args: Array<String>) { 
    println("Hello, ${if (args.size > 0) args[0] else "someone"}!")
}

2 类和属性

让我们看看一个简单的JavaBean的Person类,现在只包含一个name属性

/* Java */ public class Person { 
private final String name;
    public Person(String name) { 
        this.name = name;     
    }
    public String getName() { 
        return name; 
    }
}

在Java中,构造子的代码块内,常常包含一些重复内容:把参数赋值到响应的域。在Kotlin中,这个逻辑不需要如此多的样板代码。在第一章中5.6节,我们介绍了Java-to-Kotlin转换器:一个自动把Java代码转换到Kotlin代码的工具,代码的功能是相同的。

class Person(val name: String)

如果你熟悉现代的JVM语言,你可能见过类似的东西。这个类型的类(只包含数据,但没有代码),常常叫值实例(value object),许多语言提供了声明他们的简洁语法。注意到在转换过程中,public修饰符不见了。因为在Kotlin,public是默认的可见性,所以你能省略它

2.1 属性

你肯定知道,类的概念是封装数据和处理数据的代码到单一的实体。在Java中,数据存储到域中,通常是私有的。如果你想让类的客户端访问这个数据,你需要提供访问器方法(accessor meth-ods):一个getter、可能有一个setter。你在Person类的例子中已经看到。setter可能包含一些额外的逻辑,验证传递值,或者发送值变化的通知等等。

在Java中,域和访问器的组合,通常叫做属性(property), 很多框架较多使用这个概念。在Kotlin中,属性是语言支持的第一等功能,完全用来替代域和它的访问器方法。就像你用val和var关键词,定义一个变量,你可以同样的方式定义类的属性。声明为val的属性是只读的,而var属性是可变的,

class Person( 
    val name: String, //只读属性:自动生成一个域和简单的getter
    var isMarried: Boolean //可写属性:一个域,getter和setter
)

基本上,当你定一个属性,你就定义了相应的访问器。默认地,定义访问器也是简单的,域存储值、getter和setter来返回和更新值。如果你愿意,用不同的逻辑计算和更新属性值,来自定义访问器。上面的Person简洁的定义隐藏了实现的细节,就像原来的Java代码一样:一个类含有私有的域并且在构造子中初始化,可以用响应的getter获取到。这意味着,你可以在Java和Kotlin中使用这个类,不管这个类在哪里申明的。使用是一样的。下面是Java代码中如何使用:

/* Java */
Person person = new Person("Bob", true);
System.out.println(person.getName()); //Bob
System.out.println(person.isMarried()); //true

Kotlin的name属性在Java中的getter方法叫getName。getter和setter命名规则有个例外:如果属性名以is开始,getter没有附加的前缀,在setter名字中,is被set取代。所以,在Java中,你调用isMarried()。如下是Kotlin的结果

val person = Person("Bob", true)
println(person.name)// Bob
println(person.isMarried) //true

你不是调用getter,而是直接引用属性。逻辑是一样的,但是代码更加简洁。可变属性的setter一样,在java中你用person.setMarried(false)表达离婚,在Kotlin中person.isMarried = false。

提示 你可以在Java定义的类中使用Kotlin的属性语法。在Java类中的getter可以在Kotlin中val属性获取,getter/setter可以通过var属性获取。比如,如果在Java类定义了setName和setName的方法,那么可以通过叫name的属性获取。如果类定义了isMarried和setMarried方法,相应的Kotlin属性叫isMarried。

大多数情况下,属性有相应的支持属性,即存储属性值。但是如果值是随手计算的,比如从其他属性计算,你可以用自定义的getter表达。

2.2 自定义访问器

这个部分,你将看到怎么自定义实现一个属性访问器。假设你声明了一个长方形,它可以告诉是不是一个正方形。你没必要用单独的域存储这个信息,因为你需要动态检查高是否等于宽:

class Rectangle(val height: Int, val width: Int) { 
    val isSquare: Boolean 
    get() { //Property getter declaration
        return height == width
    } 
}

isSquere属性不需要一个域来存储它的值。它仅仅只有自定义实现的getter。这个属性被获取时每次计算。注意到,你不需要用花括号这个完整的语法,你可有写成get() = height == width。这样的属性的调用也是一样的:

val rectangle = Rectangle(41, 43)
println(rectangle.isSquare) //false

如果你想在Java中获取这个属性,你可以就像以前一样调用isSquare方法。

你可能问,是否定义一个没有参数的函数比自定义getter的属性好。这两个选项是相似的:在实现和性能是没有区别的,它们仅仅在可读性上有差别。一般讲,如果你描述一个类的特点(属性),你应该定义它为属性。

2.3 Kotlin源码布局:目录和包

Java把所有的类放进包里面。Kotlin也像Java,有包的概念。每个Kotlin文件在开头有package语句,文件中所有的声明(类、函数和属性)将放在这个包下。如果其他的文件在同一包下,里面所有的定义可以直接使用;如果这些定义在不同包里面,那么他们需要导入。就像在Java中,导入语句放置在文件的开头,使用import关键词。下面是个例子,展示包声明和导入语句:

package geometry.shapes //包声明

import java.util.Random //导入标准Java库类

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() = height == width 
} 

fun createRandomRectangle(): Rectangle {
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt()) 
}

Kotlin不会区别导入类和函数,允许你用import关键词导入任何声明。你可以通过名字导入顶层函数

package geometry.example 

import geometry.shapes.createRandomRectangle //通过名字导入函数

fun main(args: Array<String>) {
    println(createRandomRectangle().isSquare)//非常不可能打印"true"
}   

通过包名后面加上.*,你可以导入特定包里面定义的所有声明。注意,星号导入(star import)不仅使得定义包里面的类可见,而且使得顶层函数和属性可见。在上面的例子中,import geometry.shapes.* 代替显示的导入,也使得使得代码正常编译。

在Java中,目录结构和包的层级是重复的。在Kotlin中你可以在同个文件中定义多个类。Kotlin也没限制磁盘上源文件的结构。你可以用目录结构来组织你的文件。比如,你可以在文件shapes.kt中定义geometry.shapes包的所有内容,然后把这个文件放在geometry目录下,没有必要创建shapes文件夹。


package hierarchy

但是,在大多数情况下,跟随Java目录结构和根据包结构把源码组织成目录,是最佳实践。特别是Kotlin和Java混合的项目,坚持这样的结构特别重要。因为这样做可以让你逐步迁移代码,而没有引入意外的情况。但是请你不要犹豫把多个类合成到同一个文件,特别是当类很小的时候(在Kotlin中,这些经常存在)。

3 选项的表述和处理:枚举和“when”

在这一节中,我们将讲述when结构。它可以被想成Java中的switch替代品,但是更加强大和更常使用。同时,有一个在Kotlin中声明枚举的例子,然后讨论智能强转的概念。

3.1 声明枚举类

让我们加一些想象的明亮照片到这个严肃的书籍,看看下面颜色的枚举

enum class Color { 
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET 
}

与Java的仅仅有关键词enum相比,Kotlin声明使用更多的关键词,这是比较少见的。在Kotlin中,enum就是所谓的软关键词(soft keyword):当它放置在class关键词之前,它才有特有的意义。但是你可以在其他的地方,把它当成常规的名字使用。另外一方面,class还是一个关键词,你可以用clazz和aClass来声明变量。
就像在Java中,枚举不是值的列表:你可以在枚举类中声明属性和方法:

enum class Color( 
    val r: Int, val g: Int, val b: Int //声明枚举常量的属性
) {
    RED(255, 0, 0), //当每个变量创建的时候,指定属性值
    ORANGE(255, 165, 0), //逗号是必须的
    YELLOW(255, 255, 0), 
    GREEN(0, 255, 0), 
    BLUE(0, 0, 255),
    INDIGO(75, 0, 130), 
    VIOLET(238, 130, 238);
    fun rgb() = (r * 256 + g) * 256 + b//定义枚举的方法
}
println(Color.BLUE.rgb())//255

枚举常量就像你看见的正常的类一样,有相同的构造子和属性声明。当你定义一个枚举常量,你需要为它提供属性值。这个例子中展示了Kotlin语法唯一需要分号的地方:在枚举类中如果你定义任何方法,分号区分了枚举常量列表和方法声明。

3.2 用“when”来处理枚举类

你记得孩子如何利用助记短语来记忆彩虹的颜色吗?这就是一个:“Richard Of York Gave Battle In Vain!”假设你需要一个函数来给你为每个颜色一个助记(你不想把这些信息存储在枚举里面)。在Java中,你使用switch语句,在Kotlin中,响应的结构是when。

就像if一样,when也是一个返回值的表达式,所以你可以写一个函数,它的表达式体直接返回when表达式。如下:

fun getMnemonic(color: Color) = //直接返回一个“when”的表达式
    when (color) { //如果颜色等于枚举常量,返回响应的字符串
        Color.RED -> "Richard" 
        Color.ORANGE -> "Of" 
        Color.YELLOW -> "York" 
        Color.GREEN -> "Gave" 
        Color.BLUE -> "Battle" 
        Color.INDIGO -> "In" 
        Color.VIOLET -> "Vain"
    }
}
println(getMnemonic(Color.BLUE)) // Battle

不像Java,你不需要为每个分支写break语句(缺少break是Java代码中引入错误的原因)。你可以在同个分支结合值,用逗号来分离:

fun getWarmth(color: Color) = when(color) { 
    Color.RED, Color.ORANGE, Color.YELLOW -> "warm" 
    Color.GREEN -> "neutral" 
    Color.BLUE, Color.INDIGO, Color.VIOLET -> "cold" 
}
 println(getWarmth(Color.ORANGE)) //warm

上面的例子用全名来使用枚举常量,指定Color枚举类名。你可以用导入常量来简化代码:

import ch02.colors.Color //导入声明在另外一个包的Color类
import ch02.colors.Color.*//用名字显示导入枚举常量

fun getWarmth(color: Color) = when(color) { 
    RED, ORANGE, YELLOW -> "warm" //用名字导入常量
    GREEN -> "neutral" 
    BLUE, INDIGO, VIOLET -> "cold"
}

3.3 使用任意实例的“when”

Java中的switch,需要使用常量(枚举常量、字符串或者数字字面常量)作为分支条件,但是在Kotlin中,when允许任何的实例。下面我们写一个混合两者颜色的函数,如果它们可以在这个小的调色板中能够混合。

fun mix(c1: Color, c2: Color) = 
    when (setOf(c1, c2)) {//when表达式的参数可以是任何实例,用来被分支条件检查
        setOf(RED, YELLOW) -> ORANGE//枚举可以混合的颜色对
        setOf(YELLOW, BLUE) -> GREEN
        setOf(BLUE, VIOLET) -> INDIGO 
        else -> throw Exception("Dirty color")//执行这个,如果没有分支可以匹配
    }
println(mix(BLUE, YELLOW))//GREEN

Kotlin标准库中含有一个setOf的函数,用来创建Set,包含参数指定的实例;一个set是一个集合,它的项的次序并不重要。所以,如果setOf(c1, c2)和setOf(RED, YELLOW)是相等的,那么意味着要不然c1是RED和c2是YELLOW,或者相反。

3.4 用没有参数的when

上面的例子有点效率低下,因为每次你调用这个函数,它都会创建几个Set实例,仅仅是用在检查两个颜色是否匹配另外两个颜色。正常情况下,通常不是个问题。但是如果这个函数经常被调用,那么为了避免GC,值得用另外一种方式来重写这个代码。你可以用不带参数的when表达式完成。代码虽然可读性差一点,但是这是为了达到更好性能付出的代价。

fun mixOptimized(c1: Color, c2: Color) = 
    when { 
        (c1 == RED && c2 == YELLOW) || (c1 == YELLOW && c2 == RED) -> ORANGE
        (c1 == YELLOW && c2 == BLUE) || (c1 == BLUE && c2 == YELLOW) -> GREEN
        (c1 == BLUE && c2 == VIOLET) || (c1 == VIOLET && c2 == BLUE) -> INDIGO
        else -> throw Exception("Dirty color")
    } 
println(mixOptimized(BLUE, YELLOW)) //GREEN

如果when表达式没有参数,它的分支可以是任何的布尔值。mixOptimized函数和上面的mix做相同的事情。优点是不需要创建任何额外的实例,但是代价是更难阅读。

3.5 智能强转:结合类型检查和强转

作为整个部分的例子,写一个简单算术表达式的求值,比如(1+2)+4。其他的算术操作(减乘除)也可以用类似的方式实现,你可以当做一个练习。
第一, 你怎么编码这个表达式?你可以在树状结构中存储,每个节点是一个总数(Sum)或者一个数字(Num)。Num永远是叶子节点,而Sum节点有两个作为sum操作的参数的子节点。以下列表显示的是一个用来编码表达式的类的简单结构:Expr的接口,它的Num和Sum两个实现类。需要注意的是,Expr没有声明任何方法,仅仅是用作标记接口,提供相同类型的不同种类表达式。

interface Expr 
class Num(val value: Int) : Expr 
class Sum(val left: Expr, val right: Expr) : Expr

Sum存储了左边和右边Expr类型的参数的引用。在这个小例子中,它们可以使Num或者Sum。为了存储表达式(1+2)+4,你可以穿件一个实例:Sum(Sum(Num(1), Num(2)), Num(4))。如下图展示的树状结构


树状表达式

我们看看怎么计算一个表达式的值:

println (eval(Sum(Sum(Num(1), Num(2)), Num (4)))) //7

Expr接口有两个实现,所以对于一个表达式求最终的值,你可以有两种选择:

  • 如果表达式是一个数字,返回相应的值
  • 如果是一个和,对左边和右边表达式求值,返回它们的和

首先,我们用通常的Java方式来写这个函数,然后用kotlin的方式重构。在Java中,你可能用if语句序列来检查选项,所以让我们在Kotlin中用同样的方法:

fun eval(e: Expr): Int { 
    if (e is Num) { 
        val n = e as Num //显式的强转到Num是冗余的
        return n.value 
    } if (e is Sum) { 
        return eval(e.right) + eval(e.left) //变量e是智能强转
    } 
    throw IllegalArgumentException("Unknown expression")
}
println(eval(Sum(Sum(Num(1), Num(2)), Num(4)))) //7

在Kotlin中,检查一个变量是不是某种类型用is检查。如果你在C#编程过,这个概念会很熟悉。is检查和Java中的instanceOf类似。但是在Java中,如果你已经检查了一个变量是否是某种类型,同时想取得这个类型的属性,你需要在instanceOf检查后面再加一个显式的类型转换。初始的变量需要不只使用一次,通常需要把类型转换后的变量存储到单独的变量中。在kotlin中,编辑器为你做了这些工作。如果你检查变量为某种类型,你没必要在后面再类型转换。你可以当做你想检查的类型来使用它。事实上,编译器,编译为我们类型转换了,我们叫它只能智能类型转换(smart cast)

在eval函数中,在你检查这个变量e是否是Num类型后,编译器解释它为Num变量。然后你可以不需要显式的类型转换就可以取得Num的value属性。同样的情况适用于Sum的右边和左边的属性: 在相应的情形下你只需要写e.right和e.left。在IDE中,智能转换的值用一个背景色来强调,所以你可以很容易知道这个值是预先检查了的,如下:


image

智能转换只有变量在is检查后没有被改变。当你对一个类的属性进行智能转换,属性必须是val,而且不能有自定义的存取器。否则不能确定每次获得这个属性将获得同样的值。一个显式转换到特定类型用as关键词来表达:

val n = e as Num

3.7 代码块作为if和when的分支

if和when都可以用代码块作为分支。在这个例子中,代码块中最后最后一个表达式作为结果。如果你想在例子函数中加日志,你可以在代码块中完成,并用最后一个值返回。

fun evalWithLogging(e: Expr): Int =
    when (e) { 
        is Num -> { 
            println("num: ${e.value}") 
            e.value //如果e是Num类型,这是代码块最后一个表达式,并被返回
        } 
        is Sum -> { 
            val left = evalWithLogging(e.left)
            val right = evalWithLogging(e.right) 
            println("sum: $left + $right") 
            left + right//如果表达式被返回当e是Sum类型
        } 
        else -> throw IllegalArgumentException("Unknown expression")
    }
    println(evalWithLogging(Sum(Sum(Num(1), Num(2)), Num(4)))) 
    //num: 1 
    //num: 2 
    //sum: 1 + 2 
    //num: 4 
    //sum: 3 + 4 
    //7

“代码块中最后一个表达式是返回值”这个规则,在使用代码块而且期待返回一个结果的情况西安,所有情形下都成立。你将在本章结束的时候,同样的规则在try代码体和catch子句下同样适用。在第五章论述lambada表达式下它的应用。但是在2.2节中提到,这个规则对于常规的函数式不适用的。一个函数可以是没有代码块的表达式体,或者是一个有显示的return语句的代码块体

4 迭代事物:while和for循环

for循坏只存在一种形式,相对于Java的for-each循环。就像C#里面的写法:for <item> in <elements>。不存在Java中的通常for语法。

4.1 while循环

和Java对应的循环一样的语法

while (condition) { //当条件为真时,代码体执行
    /*...*/ 
}
do {//无条件的执行一次,之后当条件为真时执行
    /*...*/ 
} while (condition)

4.2 数字的迭代:范围和累进

由于不存在Java中通常的for语法,Kotlin用范围(ranges)这个概念。范围是两个值之间的间距,这两个值为开始和结束的值,用..操作子表示。

val oneToTen = 1..10

范围在Kotlin是自闭的(Closed)或者自包含(inclusive),这意味着第二个值总是范围的一部分。如果你迭代范围内的所有的值,这样的范围也叫累进(progression)

让我们用整数的范围玩Fizz-Buzz游戏。参与者轮流递增式数数,用fizz单词替代任何可以被三整除的数字,用buzz单词替代任何可以被五整除的数字。如果一个数字同时是三和五的乘数,我们叫“FizzBuzz”。

如下列表打印了从1到100之间的正确答案。注意这么用没有参数的when表达式检查可能的条件:

fun fizzBuzz(i: Int) = when { 
    i % 15 == 0 -> "FizzBuzz " //i可以被15整除,返回FizzBuzz。就像在Java中,%是模操作
    i % 3 == 0 -> "Fizz " //i可以被5整除,返回Buzz
    i % 5 == 0 -> "Buzz " //i可以被3整除,返回Fizz
    else -> "$i " //Else返回这个数字本身
}
for (i in 1..100) { //迭代整数范围1..100
    print(fizzBuzz(i))
}
//1 2 Fizz 4 Buzz Fizz 7 ...

如果你觉得厌倦了这些规则,想要把规则搞的复制一些。让我们从100倒过来数,而且只包括偶数:

for (i in 100 downTo 1 step 2) { 
    print(fizzBuzz(i)) 
}
//Buzz 98 Fizz 94 92 FizzBuzz 88 ...

当你以一个步长step迭代一个累进,这可以忽略一些数字。这个步长可以是负数,这样的话累进向后而不是向前。这这个例子中,100 downTo 1 是一个(步长为-1)向后的累进。然后步长改变它的绝对值为2,同时保持方向(事实上是,设置步长为-2).

就像前面提到的,..语法创建了一个包含终点(..右边的值)的一个范围。在许多情况下,迭代半自闭的范围,即不包含指定的终点,这样会更加方便。为了创建这样一个范围,用until函数实现。比如,for (x in 0 until size)循环等于for (x in 0..size-1),但是它表达的意思更加清楚。

4.3 map的迭代

我们提到过,追常见的情形是,for...in循环是迭代一个集合。这个是和Java是一样的,所以毋庸赘言。下面我们看看怎么迭代一个map。

举个例子,让我看看一个小程序,打印字符的二进制表示。仅仅为了展示的目的,你将存储二进制表示到一个map之中。下面的代码创建了一个map,用一些字母的二进制填进去,然后打印map里面的内容。

val binaryReps = TreeMap<Char, String>()//用TreeMap,所以键是排序的

for (c in 'A'..'F') { //用字符的范围迭代从A到F的字符
    val binary = Integer.toBinaryString(c.toInt()) //ASCII编码转换到二进制
    binaryReps[c] = binary//在map中用c键存储值
}
for ((letter, binary) in binaryReps) { //迭代一个map,把键值对赋值到两个变量
    println("$letter = $binary")
}

..语法创建范围不仅仅对数字适用,也对字符适用。我们用它迭代所有的字符,从A到(包括)F。

上面显示了,for循环让你解构迭代集合的元素,在这个例子中,是map里面键值对的集合。解构的结果存储到两个不同值中:letter接受键,而binary接受值。另外一个有用的技巧是,用键获取和更新一个map里面的值。不是调用get和put,你用map[key]读值,而用map[key] = value设置。代码binaryReps[c] = binary相当于Java里面的binaryReps.put(c, binary)。输出如下:

A = 1000001 B = 1000010 C = 1000011 D = 1000100 E = 1000101 F = 1000110

你可有用同样的结构语法迭代一个集合,同时记录当前项的索引。你不必手动的创建一个独立的存储索引的变量。编码打印如你所料,如下:

val list = arrayListOf("10", "11", "1001") 
for ((index, element) in list.withIndex()) { 
    println("$index: $element") 
}
//0: 10 
//1: 11 
//2: 1001

4.4 用in检查集合和范围的属性

用in操作子检查一个值是否在范围里面,或者想法,用!in检查是否一个值是否不在一个范围里面。下面看看怎么用in检查一个字符是否属于字符范围里面:

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z' 
fun isNotDigit(c: Char) = c !in '0'..'9'
println(isLetter('q')) //true
println(isNotDigit('x')) //true

背下地,没有任何诡计:检查字符编码是否在第一个和最后一个编码之间的某个地方。但是这个逻辑被隐藏在标准库里面范围类的实现里面。

c in 'a'..'z'//变换成a <= c && c <= z

in和!in操作子也可以在when表达式里面使用

fun recognize(c: Char) = when (c) { 
    in '0'..'9' -> "It's a digit!"
    in 'a'..'z', in 'A'..'Z' -> "It's a letter!" 
    else -> "I don't know…"
}
println(recognize('8')) //It's a digit!

范围也不限于字符。如果你有任何支持比较实例的类(实现java.lang.Comparable接口),你可以创建那种类型实例的范围。如果你有这样的范围,你不能枚举这个范围的所有的实例。想想这个:比如,你能枚举在“Java”和“Kotlin”之间的所有的字符串吗?是的,你不能。但是你依然可以用in操作子检查另外实例是否属于这个范围:

println("Kotlin" in "Java".."Scala") //和“Java” <= “Kotlin” && “Kotlin” <= “Scala”一样
//true

字符串在这里是按字母比较的,因为那是String类怎么实现Comparable接口的。同样的in检查对集合也适用:

println("Kotlin" in setOf("Java", "Scala")) //这个集没有“Kotlin”字符串
//false

5 Kotlin中的Exception

Kotlin中的异常处理与Java或者其他语言中的处理方式相似。一个函数可以以正常方式结束,或者当错误发生的时候抛出异常。函数调用者捕获这个异常并处理它;如果没有,异常重新在调用栈向上抛。

Kotlin中的异常处理语句的基本形式和Java是相似的。你可以以不足为奇的方式抛出一个异常:

if (percentage !in 0..100) { 
    throw IllegalArgumentException( "A percentage value must be between 0 and 100: $percentage") 
}

就像其他的类,你不需要用new关键词创建异常实例。不像Java,在Kotlin中,throw结构是一个表达式,可以用作为其他表达式的一部分:

val percentage = 
    if (number in 0..100) 
        number
    else 
        throw IllegalArgumentException( //“throw” 是一个表达式
            "A percentage value must be between 0 and 100: $number")

5.1 try、catch和finally

就像Java之中,可以用try结构,和catch和finally子句处理异常。如下,读取指定文件的一行,尝试解析为个数字,然后返回一个数字,如果这行不是有效的数字,返回null。

fun readNumber(reader: BufferedReader): Int? { //不必要显式地指定需要这个函数抛出的异常
    try { 
        val line = reader.readLine() 
        return Integer.parseInt(line) 
    } catch (e: NumberFormatException) { //异常的类型在右边
        return null 
    } finally { //finally就像在Java一样的
        reader.close()
    }
}
val reader = BufferedReader(StringReader("239"))
println(readNumber(reader))
//239

在段代码和Java最大的不同是不需要throws子句:如果你在Java中写这个函数,你必须显式地在函数声明后面写throws IOException。你必须这么做是因为IOException是受检查的异常checked exception。在Java中,一个异常必须显式的处理。你不得不声明函数可以抛的所有的受检查异常。如果你调用其他的函数,你需要处理它的受检查的异常,或者声明你的函数抛出这些异常。
就像其他现代JVM语言,Koltin不区别受检查和不受检查的异常。你需要指定一个函数抛出的异常,你可以也可以不处理这些异常。这个设计决定是基于Java中使用受检查异常的实践。经验表明,Java规则常常需要很多无意义的代码从新抛出或者忽略异常,这个规则并不能一致地避免发生的错误。

在上面的例子中,NumberFormatException是一个不受检查的异常。所以Java编译器不会强迫你捕获这个异常,你可以很容易的看见运行时的异常。这相当令人遗憾,因为不有效的输入数据是经常的事情,应该更优雅的处理。同时,BufferedReader.close方法也能抛出一个IOException异常,这是个需要处理的受检查的异常。如果关闭一个流失败了,大部分代码不能采取任何有意义的行动,所以需要从close方法捕获异常的代码基本是样板代码。

那么关于Java 7的try-with-resources怎么样呢?Kotlin没有对应的特别的语法;它被处理成一个库函数。

5.2 try作为一个表达式

为了显示Java和Kotlin直接一个重要区别,让我们稍微改变下这个例子。移除fianlly部分(因为你已经知道这个怎么工作),然后加一些代码打印从这个文件读取的数字。

fun readNumber(reader: BufferedReader) {
    val number = try { 
        Integer.parseInt(reader.readLine()) //成为try表达式的值
    } catch (e: NumberFormatException) {
        return 
    } 
    println(number)
}

val reader = BufferedReader(StringReader("not a number"))
readNumber(reader)//没有打印任何数字

Kotlin中try关键词,就像if和when,引进了一个表达式,你可以把它的值赋值给一个变量。不像if,你一直需要把语句保函在花括号中。就像其他语句,如果包涵多个表达式,try表达式的值是最后一个表达式的值。在这个例子中,在catch代码块中有return语句,所以这个函数在catch代码块后不会再进行。如果你想继续这个执行,catch语句也需要一个值,这个值是最后表达式的值:

fun readNumber(reader: BufferedReader) {
    val number = try { 
        Integer.parseInt(reader.readLine()) //没有异常发生时使用这个值
    } catch (e: NumberFormatException) {
        null //异常发生时使用null值
    }
    println(number)
}
val reader = BufferedReader(StringReader("not a number"))
readNumber(reader)//异常被抛出,所以函数打印null
//null

这时候如果你不耐烦了,你可以用类似Java中的写法,开始在Kotlin中写代码。当你读这本书的时候,你将继续学习怎么改变你习惯的思考方式,使用这个新语言的全部功能

Kotlin