Skip to content

3. Kotlin 语言基础

3.1. 引言

我们先把 Kotlin 当作一门传统的编程语言来看待。类将在下一章介绍。程序由两部分组成:

  • 数据;
  • 操作数据的指令。

我们通常努力把数据与指令分开:

Image

本章中的所有示例都属于课程代码中 [03-basics] 文件夹里的 Gradle 项目。如第 2 章“搭建开发环境”所述,每个程序都包含在一个文件中,该文件位于以程序名小写形式命名的包中:程序 [Basics04.kt] 位于文件夹 [src/main/kotlin/basics04] 中,并以 [package basics04] 这一行开头。你可以点击 IntelliJ IDEA 中位于 [main] 函数旁边边栏里的绿色三角形来运行它,也可以在命令行中,在项目文件夹下,使用命令 [gradlew -q run -Pmain=basics04.Basics04Kt] (在 Linux 和 macOS 上为 [./gradlew] )来运行。[-q] (“quiet”)选项会抑制 Gradle 消息:只保留程序的输出。我们将在下一节解释名称 [basics04.Basics04Kt]。这些示例使用法语的语言和格式约定(“区域设置”fr-FR)运行,就像在法语版 Windows 机器上一样。我们将看到,这只影响用特定 格式格式化的数字和日期:把浮点数直接转换为字符串时,始终使用小数点。

3.2. 最小程序

3.2.1. 顶层 main 函数

程序 [Basics01.kt] 如下:

// 最小程序:写在任何类之外的顶层 main 函数
package basics01

fun main() {
    println("Hello world!")
    // Java 形式仍然可用:System 类的 out 字段,然后是它的 println 方法
    System.out.println("Hello world!")
    // listOf(kotlin.collections 包)无需导入即可使用
    val words = listOf("Hello", "the", "world")
    println(words)
}

结果:

1
2
3
4
> gradlew -q run -Pmain=basics01.Basics01Kt
Hello world!
Hello world!
[Hello, the, world]

说明:

  • 第 2 行:程序的包。包 把相关的声明组合在一起,就像文件夹把文件组合在一起一样。此文件中声明的所有内容的完整名称都以 [basics01.] 开头。在 Kotlin 中,与 Java 不同,文件所在的目录并不由包名决定;不过,让它们保持一致是常见的做法,我们也遵循这一做法;
  • 第 4 行:[main] 函数是程序的 入口点。关键字 [fun] 声明一个函数;[main()] 没有参数,也不返回值。该函数直接写在文件中,位于任何类之外:它是顶层函数。函数体用花括号括起来;
  • 第 5 行:[println] 函数在屏幕上打印一行。它同样是顶层函数,声明在 Kotlin 标准库的 [kotlin.io] 包中;
  • 第 7 行:同一操作的 Java 版本。[System] 是 JDK 的一个类,[out] 是它的一个字段,表示标准输出(屏幕),而 [println] 是这个对象的方法。Kotlin 直接使用所有 Java 类:这是它的主要优势之一。Kotlin 函数 [println] 实际上只是 [System.out.println] 的简写;我们将使用它;
  • 第 9 行:[words] 是一个字符串列表;列表将在第 5 章介绍。关键字 [val] 声明一个值不会改变的变量;我们没有指定它的类型:编译器根据值推断出类型,这里是 [List<String>]。[listOf] 函数属于 [kotlin.collections] 包,使用它无需 import 语句(见下文);
  • 第 10 行:列表显示时,其元素用方括号括起来;
  • 语句不以分号结尾:换行就足够了。分号只用于在一行中写多条语句。以 // 开头的行是注释,会被编译器忽略。

带两个命令行参数,它们通过 [--args] 选项传递给 Gradle:

1
2
3
4
> gradlew -q run -Pmain=basics01.Basics01Kt --args="a0 a1"
Hello world!
Hello world!
[Hello, the, world]

这些参数被忽略,因为 [main()] 函数没有用来接收它们的参数。要使用它们,请把函数声明为 [fun main(args: Array<String>)]:这样,[args] 字符串数组就会包含命令行参数。我们将在“主程序参数”一节中回到这一点。

3.2.2. main 函数及其参数

程序 [Basics02.kt] 如下:

1
2
3
4
5
6
7
8
9
// 带参数的 main 函数:命令行参数
package basics02

fun main(args: Array<String>) {
    println("Hello world!")
    println("Number of arguments received: ${args.size}")
    // contentToString 用数组的元素构建字符串
    println("Arguments: ${args.contentToString()}")
}

结果:

1
2
3
4
> gradlew -q run -Pmain=basics02.Basics02Kt --args="a0 a1"
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]

说明:

  • 第 4 行:[main] 函数在 [args] 参数中接收命令行参数。在 Kotlin 中,参数的类型写在 其名称之后,用冒号分隔:[args: Array<String>] 读作 “[args],类型为字符串数组”。这相当于 Java 中的 [String[] args] ;
  • 第 6 行:数组中的元素个数是 [args.size] (相当于 Java 的 [args.length])。在字符串中,[${args.size\}] 会被替换为花括号中表达式的值:这是一个 字符串模板,我们稍后将更详细地讨论;
  • 第 7 行:[contentToString] 函数用数组的元素构造一个字符串。它取代了 Java 方法 [Arrays.toString] ,并且与前一个函数一样,不需要任何导入。

我们没有写任何类。然而,运行程序的 Java 虚拟机(JVM)只认识类。因此,Kotlin 编译器会把文件中的顶层声明组织到它自己生成的一个类中,类名为文件名后面加上 [Kt]:对于包 [basics02] 中的文件 [Basics02.kt],这个类就是 [basics02.Basics02Kt]。这就是为什么执行命令把该程序写作 [-Pmain=basics02.Basics02Kt]。你可以通过用命令行编译器 [kotlinc] (第 2 章)编译该文件,然后用 JDK 软件包中的 [javap] 工具检查生成的类来验证这一点:

> kotlinc Basics02.kt -d classes
> ls classes/basics02
Basics02Kt.class
> kotlinr -cp classes basics02.Basics02Kt a0 a1
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]
> javap classes/basics02/Basics02Kt.class
Compiled from "Basics02.kt"
public final class basics02.Basics02Kt {
  public static final void main(java.lang.String[]);
}
> java -cp classes basics02.Basics02Kt a0 a1
Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics
    at basics02.Basics02Kt.main(Basics02.kt)
  • [kotlinc] 在包目录中生成了一个中间代码文件(“字节码”)[Basics02Kt.class];
  • 命令 [kotlinr] (Kotlin 启动器,第 2 章)通过把 Kotlin 标准库([kotlin-stdlib.jar])添加到类路径来执行这个类;
  • [javap] 显示生成的类是 [public final] ,并且 [main] 函数在其中变成了 [public static] 方法:恰好是 JVM 所期望的 [public static void main(String[] args)] 方法。对 JVM 而言,Kotlin 程序只是另一个 Java 类;
  • 当用简单的 [java] 命令启动时,该类会失败:生成的代码调用了 Kotlin 标准库中的类(这里是 [kotlin.jvm.internal.Intrinsics],它除其他事项外还检查参数不等于 [null]),而类路径中缺少它。Gradle 和 IntelliJ IDEA 会自动添加它;独立的 Kotlin 程序必须包含它(选项 [-include-runtime] ,用于 [kotlinc],第 2 章,或 Gradle 脚本,见下文)。

对于程序 [Basics01.kt],其 [main] 函数没有参数,编译器还会生成一个 [main(String[])] 方法,它只是调用第一个方法。Gradle 把它编译的类放在项目的 [build/classes/kotlin/main] 文件夹中;编译之后你可以在那里检查它们([gradlew build]):

1
2
3
4
5
6
> javap -cp build/classes/kotlin/main basics01.Basics01Kt
Compiled from "Basics01.kt"
public final class basics01.Basics01Kt {
  public static final void main();
  public static void main(java.lang.String[]);
}

与 Java 25 对比很有启发。Java 25 也允许你不声明类就编写程序(“紧凑源文件”,带有名为 [void main()] 的方法):Java 编译器随后把文件内容包装在一个以文件名命名的 隐式类中。Kotlin 自第一个版本起就这样做了,有两点不同:

  • 生成的类名为 [Basics02Kt] 而不是 [Basics02],这使名称 [Basics02] 可以留给程序员可能想在同一文件中自己编写的类。放在文件顶部的注解 ***[@file:JvmName("ClassName")]*** 允许你选择不同的名称;
  • 顶层函数被编译为 [static] 方法:调用 [main] 时不会创建任何对象,而紧凑 Java 文件中的 [void main()] 方法是实例方法。最重要的是,在 Kotlin 中,这种语法并不局限于小程序:顶层函数、变量和常量在所有程序中都被普遍使用,与类并存。

[main] 函数只能采用我们已经见过的两种形式:[fun main()] 和 [fun main(args: Array<String>)]。它不需要声明为 public:在 Kotlin 中,一切默认都是公开的。

3.2.3. 默认导入

程序 [Basics01.kt] 使用了 [println] 和 [listOf] 函数,程序 [Basics02.kt] 使用了 [contentToString] 函数,而它们都没有任何 [import] 指令。这之所以可行,是因为每个 Kotlin 文件都会自动导入标准库中的下列包:

import kotlin.*
import kotlin.annotation.*
import kotlin.collections.*
import kotlin.comparisons.*
import kotlin.io.*
import kotlin.ranges.*
import kotlin.sequences.*
import kotlin.text.*
// and, for the JVM:
import java.lang.*
import kotlin.jvm.*

由此提供了基本类型([Int]、[String]……来自 [kotlin] 包)、列表、集合和字典([kotlin.collections])、控制台输入输出([kotlin.io])、区间([kotlin.ranges])、字符串函数([kotlin.text]),以及 Java 包 [java.lang] 中的类([System]、[Math]、[Thread]……)。其他任何声明都必须在文件顶部、紧跟在 [package] 行之后导入:每个类或函数一条指令([import java.math.BigDecimal]),或每个包一条指令([import java.time.*])。没有与 Java 25 的 [import module java.base;] 指令等价的东西,而紧凑的 Java 文件会自动获得该指令:使用 JDK 的 [BigDecimal] 或 [LocalDate] 类的 Kotlin 程序必须导入它们。关于语法的一点说明:[import] 指令与其他语句一样,不以分号结尾。

3.3. Kotlin 数据类型

Kotlin 使用以下数据类型:

  • 整数,包括有符号和无符号的;
  • 实数;
  • 十进制数;
  • 字符和字符串;
  • 布尔值;
  • 对象。

3.3.1. 预定义数据类型

Kotlin 类型
对应的 Java 类型
表示的数据
字面量后缀
编码
取值范围
[Char]
[char] / [Character]
字符
 
2 字节
Unicode 字符(UTF-16),从 '\u0000' 到 '\uFFFF'
[Byte]
[byte] / [Byte]
整数
 
1 字节
[-2⁷, 2⁷-1] 或 [-128, 127]
[Short]
[short] / [Short]
整数
 
2 字节
[-2¹⁵, 2¹⁵-1] 或 [-32768, 32767]
[Int]
[int] / [Integer]
整数
 
4 字节
[-2³¹, 2³¹-1] 或 [-2147483648, 2147483647]
[Long]
[long] / [Long]
整数
L
8 字节
[-2⁶³, 2⁶³-1] 或 [-9223372036854775808, 9223372036854775807]
[UByte], [UShort], [UInt], [ULong]
(无对应类型)
无符号整数
U, UL
1、2、4、8 字节
[0, 2⁸-1], [0, 2¹⁶-1], [0, 2³²-1], [0, 2⁶⁴-1]
[Float]
[float] / [Float]
实数
F
4 字节
绝对值为 [1.4 10⁻⁴⁵, 3.4 10³⁸],7 位有效数字
[Double]
[double] / [Double]
实数
 
8 字节
绝对值为 [4.9 10⁻³²⁴, 1.8 10³⁰⁸],15 到 16 位有效数字
[Boolean]
[boolean] / [Boolean]
布尔值
 
未定义
[true], [false]
[String]
[String]
字符串
  
对 Unicode 字符序列的引用
[BigDecimal] (Java 类)
[BigDecimal]
十进制数
 
可变
精确的十进制数,精度任意
[Any]
[Object]
对象引用
  
对任意类型对象的引用

Java 区分八种 基本类型 ([int]、[double]……),其值不是对象,以及 引用类型 (类),并且为每种基本类型关联一个 包装类([Integer] 对应 [int]……)。Kotlin 取消了这种区分:在 Kotlin 中,每个值都是对象。[Int] 类型是一个带有方法的类;你可以写 [3.plus(4)] 或 [3.toString()],而 Java 不允许对 [int] 类型的字面量 3 这样做。所有类型名称都以大写字母开头,与类名一样。

这对运行时性能没有影响。只要可能,编译器就会把 [Int] 类型的变量转换为 JVM 的基本类型 [int] 的变量,只有在需要对象时才使用包装类 *[java.lang.Integer] :即值被传递给 [Any] 类型的参数(相当于 Java 的 [Object] 类)、存储在列表中,或者它可以是 [null] 时(见下文)。因此装箱和拆箱仍然存在,但由编译器处理,Kotlin 程序员无需为此操心。Kotlin 中没有 [Integer] 类型:只有 [Int]*。

以字节为单位的大小由常量 [Int.SIZE_BYTES]、[Long.SIZE_BYTES]……给出(以位为单位则是 [Int.SIZE_BITS]……),范围的边界由 [Int.MIN_VALUE] 和 [Int.MAX_VALUE] 等给出。

与 Java 不同,Kotlin 有 无符号整数:[UByte]、[UShort]、[UInt]和 [ULong],它们与对应的有符号类型大小相同,但只表示正数或零。它们的字面量以 U([42U])或 UL([42UL])为后缀。它们主要用于处理二进制数据(文件字节、地址、颜色);常见的 计算使用有符号类型进行。Kotlin 也没有十进制类型:金额使用 Java 包 [BigDecimal] 类来计算,该类位于 [java.math],我们稍后会讨论。

程序 [Basics03.kt] 说明了这几点:

// 基本类型:Kotlin 名称、Java 类和字节大小
package basics03

import java.math.BigDecimal

fun main() {
    val integer: Int = 2
    val fl: Float = 10.5F
    val d: Double = -4.6
    val s: String = "test"
    val l: Long = 1000
    val bt: Byte = 5
    val sh: Short = -4
    val c: Char = 'A'
    val b: Boolean = true
    val dec: BigDecimal = BigDecimal("10.67")
    // 在字符串中,$name 和 ${expression} 会被替换为它们的值
    println("Type of integer[$integer] : [${typeName(integer)},${Int.SIZE_BYTES}]")
    println("Type of fl[$fl] : [${typeName(fl)},${Float.SIZE_BYTES}]")
    println("Type of d[$d] : [${typeName(d)},${Double.SIZE_BYTES}]")
    println("Type of s[$s] : [${typeName(s)}]")
    println("Type of l[$l] : [${typeName(l)},${Long.SIZE_BYTES}]")
    println("Type of bt[$bt] : [${typeName(bt)},${Byte.SIZE_BYTES}]")
    println("Type of sh[$sh] : [${typeName(sh)},${Short.SIZE_BYTES}]")
    println("Type of c[$c] : [${typeName(c)},${Char.SIZE_BYTES}]")
    println("Type of b[$b] : [${typeName(b)}]")
    println("Type of dec[$dec] : [${typeName(dec)}]")
    // 字面量 3 是一个对象:它有方法
    println("The literal 3 : ${3::class.simpleName}, 3.plus(4)=${3.plus(4)}, 3.toString()=${3.toString()}")
    // 极值
    println("Int : [${Int.MIN_VALUE}, ${Int.MAX_VALUE}]")
    println("Long : [${Long.MIN_VALUE}, ${Long.MAX_VALUE}]")
    println("Double : [${Double.MIN_VALUE}, ${Double.MAX_VALUE}]")
    // 无符号整数:UByte、UShort、UInt、ULong
    val u: UInt = 4_000_000_000U
    println("u=$u, UInt : [${UInt.MIN_VALUE}, ${UInt.MAX_VALUE}], ULong.MAX_VALUE=${ULong.MAX_VALUE}")
    val minusOne = -1
    println("-1 read as an unsigned integer: ${minusOne.toUInt()}")
}

// 返回所接收对象的 Kotlin 名称和 Java 类名
fun typeName(o: Any): String {
    return "${o::class.qualifiedName},${o.javaClass.name}"
}

结果:

> gradlew -q run -Pmain=basics03.Basics03Kt
Type of integer[2] : [kotlin.Int,java.lang.Integer,4]
Type of fl[10.5] : [kotlin.Float,java.lang.Float,4]
Type of d[-4.6] : [kotlin.Double,java.lang.Double,8]
Type of s[test] : [kotlin.String,java.lang.String]
Type of l[1000] : [kotlin.Long,java.lang.Long,8]
Type of bt[5] : [kotlin.Byte,java.lang.Byte,1]
Type of sh[-4] : [kotlin.Short,java.lang.Short,2]
Type of c[A] : [kotlin.Char,java.lang.Character,2]
Type of b[true] : [kotlin.Boolean,java.lang.Boolean]
Type of dec[10.67] : [java.math.BigDecimal,java.math.BigDecimal]
The literal 3 : Int, 3.plus(4)=7, 3.toString()=3
Int : [-2147483648, 2147483647]
Long : [-9223372036854775808, 9223372036854775807]
Double : [4.9E-324, 1.7976931348623157E308]
u=4000000000, UInt : [0, 4294967295], ULong.MAX_VALUE=18446744073709551615
-1 read as an unsigned integer: 4294967295

说明:

  • 第 4 行:[BigDecimal] 类是 JDK 的子类;必须导入它;
  • 第 7 行:声明一个 [integer] 变量,类型为 [Int] ,初始化为 2。在 Kotlin 中,变量的类型写在其名称之后,用冒号分隔。我们将看到,类型通常可以省略;
  • 第 8 行:后缀 F 是必需的:字面量 10.5 的类型是 [Double],编译器拒绝把它赋给 [Float] 类型的变量;
  • 第 11 行:字面量 1000 可以赋给 [Long] 类型的变量,因为编译器知道它是一个落在该类型范围内的常量。第 12–13 行对 [Byte] 和 [Short] 类型同样适用。然而,正如我们将看到的,Kotlin 从不在数值类型之间隐式转换 变量 ;
  • 第 16 行:[BigDecimal] 数是一个对象;这里它由字符串创建,这保证了值是精确的。Kotlin 没有 [new] 运算符:通过把类的构造函数当作函数来调用来创建对象;
  • 第 18 行:在字符串中,[$integer] 会被替换为变量 [integer] 的值,而 [${typeName(integer)\}] 会被替换为写在花括号之间的表达式的值。这些 字符串模板 是在 Kotlin 中构造字符串的标准方式;我们将在下一节回到这一点。[Int.SIZE_BYTES] 是 [Int] 的字节大小;
  • 第 18 行:[typeName] 函数(第 42–43 行)期望一个 [Any] 类型的参数。因此该参数是一个对象,值 [integer] 被包装在一个 [java.lang.Integer] 对象中。该函数显示两个名称:[o::class.qualifiedName] 是 Kotlin 的完整类型名称([kotlin.Int]),而 [o.javaClass.name] 是 JVM 中对象所属类的名称([java.lang.Integer])。我们可以看到,[kotlin.Int]、[kotlin.Double]、[kotlin.String]……在运行时由 Java 类表示;
  • 第 21 行:字符串在内存中的大小无法访问:[String] 没有常量 [SIZE_BYTES];
  • 第 26 行:布尔值的大小不是由 JVM 定义的:[Boolean] 没有常量 [SIZE_BYTES];
  • 第 27 行:[BigDecimal] 是 Java 类:它的两个名称相同;
  • 第 29 行:字面量 3 是 [Int] 类型的对象:[3::class.simpleName] 是其类型的短名称,并且可以调用它的方法 [plus] 和 [toString]。我们将在第 4 章看到,+ 运算符只是书写方法 [plus] 的另一种方式;
  • 第 31–33 行:常量 [MIN_VALUE] 和 [MAX_VALUE] 指定值域的边界。注意:对于实数,[Double.MIN_VALUE] 是最小的 严格正 值(4.9 × 10⁻³²⁴),而不是最大的负数,后者是 [-Double.MAX_VALUE];
  • 第 35 行:32 位无符号整数。值 4,000,000,000 超出了 [Int] 的范围,但没有超出 [UInt] 的范围,后者最大可达 2³²-1;
  • 第 37–38 行:-1 被编码为 32 个置 1 的位;[toUInt] 函数把它们解释为无符号整数,其值等于 2³²-1;
  • 第 42–43 行:文件中的顶层函数。返回类型写在参数列表之后:[: String]。它返回([return])一个字符串。函数将在“向函数传递参数”一节中介绍。

请注意,尽管程序在法语环境下运行,实数仍以小数点显示(10.5、-4.6)。把数字转换为字符串——无论使用模板、拼接,还是 [toString] 方法——都不依赖于用户的语言:它始终产生小数点。只有 %f 这类数字格式(我们稍后讨论)才遵循语言的约定。

3.3.2. 字面量数据的写法

数据
字面量示例
[Int] 整数(32 位)
145, -7, 0xFF(十六进制), 0b1010_1010(二进制)
整数 [Long] (64 位),后缀 L
100000L, 1_000_000_000_000L, 3_000_000_000(对 [Int] 来说太大)
无符号整数 [UInt]、[ULong],后缀 U、UL
255U, 0xFFFF_FFFFU, 1UL
实数 [Double]
134.789, -45E-18 (-45 × 10⁻¹⁸), 10.0
实数 [Float],后缀 F 或 f
134.789F, -45E-18F
十进制数 [BigDecimal]
无字面量:[BigDecimal("100000.50")]
字符 [Char]
'A', 'b', '\n', '\u00e9'
字符串 [String]
"today", "c:\\chap1", "$name is ${age + 10\} years old", raw string """c:\chap1"""
布尔值 [Boolean]
[true], [false]
日期
[LocalDate.of(1954, 10, 13)] (年、月、日),表示 1954 年 10 月 13 日

在源代码中,浮点数总是带小数点书写。与 Java 一样,整数可以用十六进制(前缀 [0x])或二进制(前缀 [0b])书写,并且可以用 _ 字符分隔数字组以提高可读性:[1_000_000] 是整数一百万。Kotlin 与 Java 有几处不同,消除了同样数量的陷阱:

  • 不带后缀的整数字面量,如果能放进 [Int] 类型,就是该类型,否则是 [Long] 类型:[3_000_000_000] 是 [Long]。Java 会拒绝没有后缀 L 的这个字面量;
  • 后缀 L 必须大写:编译器会拒绝 [100l] 并给出消息 [use 'L' instead of 'l'],因为 l 太像数字 1;
  • 没有八进制表示法。Java 中 017 等于 15 的陷阱在这里不存在:编译器会拒绝 017 并给出消息 [leading zeros are not allowed in integer literals];
  • 浮点数没有“D”后缀:包含小数点或指数的字面量就是 [Double];因此 10.0 写作 10.0,而不是 10D;
  • 无符号整数有自己的后缀 U 和 UL。

字符串字面量可以包含以 \ 字符引入的 转义序列 :"\n" 表示行结束字符,而不是 \ 和 n 这两个字符的序列,"\t" 表示制表符,"\"" 表示双引号,"\\" 表示 \ 字符本身,"\$" 表示 $ 字符(见下文),"\u00e9" 表示十六进制代码为 00E9 的 Unicode 字符。因此,要写 Windows 路径 c:\chap1\paragraph3,必须写成 "c:\\chap1\\paragraph3"。Java 的文件类在 Windows 上也接受 / 分隔符:"c:/chap1/paragraph3" 指的是同一个文件。

要由多个值构造字符串,Kotlin 提供三种方法:

  • 字符串模板:在字符串中,[$name] 会被替换为变量 [name] 的值,而 [${expression\}] 会被替换为任意表达式的值:["in 10 years he will be ${age + 10\}"]。这是最易读、使用最广泛的方法。它相当于 C# 的插值字符串,例如 [$"..."];而 Java 没有这一特性(Java 21 和 22 中作为预览提出的“字符串模板”已被移除);
  • 使用 + 运算符进行 拼接:如果左操作数是字符串,右操作数就会被转换为字符串,不论其类型如何。与 Java 不同,左操作数必须是字符串:[10 + " years"] 会被编译器拒绝,因为 [Int] 类型没有接受字符串的 + 运算符;
  • 格式:["format".format(value1, value2, ...)] 或 [String.format(format, value1, value2, ...)]。这些是 Java 的格式,具有相同的 说明符,按顺序由后面的值替换:%s(任意值转换为字符串)、%d(整数)、%f(浮点数)、%.2f(保留两位小数的浮点数)、%x 或 %X(十六进制整数)、%,d(带千位分隔符的整数)、%e(科学记数法)、%n(换行)、%10s(右对齐到 10 个字符的字符串)、%-10s(左对齐)……数字格式遵循用户语言的约定。当需要控制数字的呈现方式(小数位数、对齐)时使用它们;否则,使用模板就够了。

最后,Kotlin 提供“原始字符串”:用三个引号界定的字符串,例如 ["""..."""],可以跨越多行并包含引号;最重要的是,转义序列在原始字符串中 不会 被解释:\ 字符按原样处理,因此应写成 ["""c:\chap1"""]。这对于编写 JSON、SQL、HTML 或正则表达式(第 5 章)非常有用。原始字符串支持模板。前导空格按原样保留;要让文本与代码一起缩进,请对字符串应用 [trimIndent()] 函数,它会删除所有行共有的空格,以及为空的第一行和最后一行;或者应用 [trimMargin()] 函数,它会删除 | 字符(“边距”)之前的所有内容。Java 15 的文本块就是以此为模型设计的;它们会自动删除公共缩进,但会解释转义序列。

程序 [Basics04.kt] 演示了这些不同的写法:

// 字面数据的表示法
package basics04

import java.math.BigDecimal
import java.time.LocalDate
import java.time.format.DateTimeFormatter

fun main() {
    // 整数:十进制、十六进制(0x)、二进制(0b),分隔符 _
    val i1 = 145; val i2 = -7; val i3 = 0xFF; val i4 = 0b1010_1010
    val l1 = 100000L; val l2 = 1_000_000_000_000L; val l3 = 3_000_000_000
    println("integers: $i1 $i2 $i3 $i4 $l1 $l2 $l3")
    // 无符号整数:后缀 U
    val u1 = 255U; val u2 = 0xFFFF_FFFFU
    println("unsigned: $u1 $u2")
    // 实数
    val d1 = 134.789; val d2 = -45E-18; val d3 = 10.0
    val f1 = 134.789F
    val m1 = BigDecimal("100000.50")
    println("reals: $d1 $d2 $d3 $f1 $m1")
    // 字符和布尔值
    val c1 = 'A'; val c2 = '\u00e9'
    val b1 = true
    println("characters: $c1 $c2, boolean: $b1")
    // 日期:(年, 月, 日)
    val birth = LocalDate.of(1954, 10, 13)
    println("date: $birth")

    // \ 字符引入转义序列
    val path = "c:\\chap1\\paragraph3"
    println(path)
    println("line 1\nline 2\t[tab]")
    // $ 字符在字符串中写作 \$
    println("price: 10 \$, quotes: \"yes\"")

    // 构建字符串:模板、连接或格式化
    val name = "dupont"
    val age = 23
    println("$name is $age years old, in 10 years he will be ${age + 10}")
    println(name + " is " + age + " years old, in 10 years he will be " + (age + 10))
    println(String.format("%s is %d years old, in 10 years he will be %d", name, age, age + 10))
    // format 函数作用于格式字符串本身
    println("d1=%.1f, i3 in hexadecimal=%X, l2=%,d".format(d1, i3, l2))
    println("i4 in binary=${i4.toString(2)}, name in upper case=${name.uppercase()}")
    println("date=${birth.format(DateTimeFormatter.ofPattern("EEEE d MMMM yyyy"))}")

    // 原始字符串:没有转义序列,无需转义引号
    val json = """
        {
          "name": "dupont",
          "path": "c:\chap1"
        }
        """.trimIndent()
    println(json)
    // 原始字符串接受模板
    val json2 = """{ "name": "$name", "age": $age }"""
    println(json2)
    // trimMargin:边距截止于 | 字符
    val text = """
        |A raw string
        |   on several lines, costing 10 ${'$'}
        """.trimMargin()
    println(text)
}

结果:

> gradlew -q run -Pmain=basics04.Basics04Kt
integers: 145 -7 255 170 100000 1000000000000 3000000000
unsigned: 255 4294967295
reals: 134.789 -4.5E-17 10.0 134.789 100000.50
characters: A é, boolean: true
date: 1954-10-13
c:\chap1\paragraph3
line 1
line 2    [tab]
price: 10 $, quotes: "yes"
dupont is 23 years old, in 10 years he will be 33
dupont is 23 years old, in 10 years he will be 33
dupont is 23 years old, in 10 years he will be 33
d1=134,8, i3 in hexadecimal=FF, l2=1 000 000 000 000
i4 in binary=10101010, name in upper case=DUPONT
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }
A raw string
   on several lines, costing 10 $

说明:

  • 第 4–6 行:导入程序使用的 JDK 类;
  • 第 10 行:一行上有四个声明,用分号分隔。[0xFF] 是 255,[0b1010_1010] 是 170。变量类型没有指定:编译器根据值推断它们,这里是 [Int];
  • 第 11 行:后缀 L 把 100000 变成 [Long]。字面量 3_000_000_000 对 [Int] 来说太大,它无需后缀就是 [Long] ;
  • 第 14 行:两个 [UInt] 类型的无符号整数。0xFFFF_FFFFU 的 32 位全部置 1,等于 2³²-1;
  • 第 17 行:-45E-18 显示为 -4.5E-17:这是同一个值,经过了规范化。浮点数 10.0 显示为 10.0:把 [Double] 转换为字符串时,始终至少产生一位小数;
  • 第 19 行:[BigDecimal] 保留书写时的小数位数:100000.50,而不是 100000.5;
  • 第 22 行:序列 \u00e9 表示十六进制代码为 00E9 的 Unicode 字符,即 é;
  • 第 26 行:日期。[LocalDate] 类(JDK 的 [java.time] 包)表示不含时间的日期。Kotlin 没有自己的日期类:它使用 Java 的。其到字符串的转换使用国际格式 ISO 8601(年-月-日),与语言无关。我们将在第 5 章介绍日期;
  • 第 30 行:每个 \\ 表示单个 \ 字符;
  • 第 32 行:一个换行符和一个制表符;
  • 第 34 行:序列 \$ 和 \";
  • 第 39 行:模板。[$name] 和 [$age] 被替换为变量的值,而 [${age + 10\}] 被替换为表达式的值。只要 $ 后面不是简单的变量名,就必须使用花括号;
  • 第 40 行:通过拼接构造的同一文本。[(age + 10)] 周围的括号至关重要:没有它们,+ 运算符会从左到右求值,字符串会先接收 23,再接收 10,结果就是“in 10 years he will be 2310”。模板没有这个陷阱;
  • 第 41 行:使用格式构造的同一文本;
  • 第 43 行:几个格式说明符:%.1f(一位小数)、%X(大写十六进制)、%,d(千位分隔符)。这些格式遵循法语的约定:小数逗号,以及作为 千位分隔符的细不换行空格。Kotlin 库的 [format] 函数应用于格式字符串本身;它调用 Java 函数 [String.format];
  • 第 44 行:[toString(base)] 函数把整数转换为任意进制的字符串,这里是 2 进制;[uppercase()] 函数把字符串转换为大写。请注意,模板可以包含函数调用;
  • 第 45 行:自定义日期格式:星期几(EEEE)、日(d)、用文字表示的月份(MMMM)、年(yyyy)。星期和月份的名称是法语的,即用户的语言。请注意,模板可以在花括号内包含引号;
  • 第 48–53 行:跨越多行的原始字符串。引号按原样书写,\chap1 不需要写成 \\chap1。[trimIndent()] 函数删除了所有行共有的八个空格,以及第一行(它是空的,紧跟在开头引号之后)和最后一行(在结尾引号之前只包含空格);
  • 第 56 行:单行原始字符串,这样就无需对 JSON 中的引号进行转义,其中有两个模板;
  • 第 59–62 行:[trimMargin()] 函数从每一行中删除标记边距的空格和 | 字符:放在 | 之后的三个空格被保留。由于转义序列在原始字符串中不会被解释,$ 字符写作 [${'$'\}]:一个表达式为 '$' 字符的模板。这里,由于 $ 后面是换行符,它本来可以单独写;但是,[$name] 会被替换为 [name] 的值。自 Kotlin 2.2 起,你也可以在字符串前加上多个 $ 符号:在 [$$"""{ "$schema": "$$name" \}"""] 中,需要两个 $ 符号来引入模板,而 [$schema] 保持不变。

3.3.3. 数据声明

3.3.3.1. 声明的作用

程序处理由名称和类型刻画的数据。这些数据存储在内存中。程序编译时,编译器会为每个数据分配一个由地址和大小刻画的内存位置。它根据程序员所做的声明来完成这件事。此外,这些声明使编译器能够检测编程错误。因此,操作 [x = x * 2] 在 [x] 是字符串时将被判定为无效。

3.3.3.2. 只读变量与可变变量

Kotlin 有两个用于声明变量的关键字:

  • [val] (“value”)声明一个 只读 变量:它只被赋值一次,之后不能更改。这相当于 Java 的 [final] 变量;
  • [var] (“variable”)声明一个 可变 变量,可以被赋予新值。

语法如下:

val name: Type = value
var name: Type = value

类型通常省略:编译器随后根据值推断它(类型推断)。因此 Kotlin 关键字 [var] 与 Java 10 中的含义不同:在 Java 中,[var] 表示“推断类型”;在 Kotlin 中,它表示“可变”,而类型既可以用 [val] 推断,也可以像用 [var] 一样推断。声明时没有初始化的变量必须有显式类型;在被赋值之前不能使用它(消息 [variable 'b' must be initialized])。

Kotlin 的惯例是用 所有 变量都使用 [val] 声明,只有当变量的值确实预期会改变时才使用 [var]。这提高了程序的可读性:当你读到 ***[val total = ...]*** 时,就知道 *[total] 会保持该值。IntelliJ IDEA 还能帮助识别任何名为 [var] 而实际上可能是 [val]* 的变量。

Kotlin 区分大写和小写字母:变量 [END] and [end] 是不同的。按惯例,变量名以小写字母开头,之后每个单词以大写字母开头:[priceExclTax], [nbChildren]。

3.3.3.3. 声明常量

像 [val] 这样的变量不会改变其值,但其值可能直到运行时才知道([val today = LocalDateTime.now()])。严格地说,常量是在编译时已知的值。Kotlin 使用关键字 [const val] 来声明它:

const val NAME = value

[const val] 常量声明在文件的顶层(函数之外),或者声明在 [object] 或 [companion object] 中,我们将在第 4 章介绍。它只能是基本类型([Int]、[Double]、[Boolean]……)或 [String] 类型,并且其值必须能由编译器计算出来。例如:

const val VAT_RATE = 0.2

编译器随后会把 [VAT_RATE] 的每一处出现替换为其值,就像 Java 编译器对用常量初始化的 [static final] 字段所做的那样。下面的尝试会被拒绝:

1
2
3
4
5
const val START = LocalDate.of(2026, 1, 1)
error: const 'val' has type 'LocalDate!'. Only primitive types and 'String' are allowed.
fun main() {
    const val N = 3
error: modifier 'const' is not applicable to 'local variable'.

([LocalDate!] 中的感叹号将在下一节解释)。为什么要声明常量?

  • 如果给常量起一个有意义的名称,程序更容易阅读;
  • 如果需要更改“常量”,程序更容易修改。因此,如果增值税税率变为 0.25,只需修改定义其值的语句:[const val VAT_RATE = 0.25]。如果程序中显式使用了 0.2,就需要修改许多语句。

按惯例,与 Java 一样,常量的名称用大写字母书写,单词之间用 _ 字符分隔:[VAT_RATE]、[MAX_VALUE]。局部变量,例如 [val],仍使用常规名称。

程序 [Basics05.kt] 如下:

// 常量和变量
package basics05

import java.time.LocalDateTime

// 顶层常量:const val,名称大写
const val VAT_RATE = 0.2

fun main() {
    // 只读变量:val
    val currency = "euros"
    // 可变变量:var
    var priceExclTax = 100.0
    println("Price incl. tax: ${priceExclTax * (1 + VAT_RATE)} $currency")
    priceExclTax = 250.0
    println("Price incl. tax: ${priceExclTax * (1 + VAT_RATE)} $currency")

    // 显式指定类型的数据
    val i: Int = 2
    println("Type of val i: Int = 2 : ${typeName(i)}")
    // 隐式类型的数据:类型由值推断
    val j = 3
    println("Type of val j = 3 : ${typeName(j)}")
    val today = LocalDateTime.now()
    println("Type of val today : ${typeName(today)}")
    val x = 3.5
    val y = 3.5F
    val z = 10L
    val name = "dupont"
    println("x : ${typeName(x)}, y : ${typeName(y)}")
    println("z : ${typeName(z)}, name : ${typeName(name)}")
    // 不带初始值声明的变量:必须写明其类型
    val b: Int
    val a = 1
    val c = 3
    b = a + c
    println("a=$a, b=$b, c=$c")
}

// 返回所接收对象类型的短名称和完整名称
fun typeName(o: Any): String = "${o::class.simpleName},${o::class.qualifiedName}"

结果:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=basics05.Basics05Kt
Price incl. tax: 120.0 euros
Price incl. tax: 300.0 euros
Type of val i: Int = 2 : Int,kotlin.Int
Type of val j = 3 : Int,kotlin.Int
Type of val today : LocalDateTime,java.time.LocalDateTime
x : Double,kotlin.Double, y : Float,kotlin.Float
z : Long,kotlin.Long, name : String,kotlin.String
a=1, b=4, c=3

说明:

  • 第 7 行:顶层常量。编译器把它作为 [Basics05Kt] 类中的 [public static final double] 字段;
  • 第 11 行:只读局部变量,类型为 [String] (推断得出);
  • 第 13 行:可变变量。字面量 100.0 使 [priceExclTax] 的类型为 [Double]。如果写成 [var priceExclTax = 100],变量的类型就会是 [Int],第 15 行对 250.0 的赋值就会被拒绝;
  • 第 14 行:结果是 [Double],至少显示一位小数:120.0;
  • 第 15 行:[priceExclTax] 被赋予新值;
  • 第 19 行:显式指定类型的数据值;
  • 第 20 行:[typeName] 函数(第 41 行)显示其参数类型的短名称([simpleName])和完整名称([qualifiedName]);
  • 第 22 行:隐式指定类型的值。因为 3 的类型是 [Int],所以 [j] 的类型将是 [Int];
  • 第 24 行:因为 [LocalDateTime.now()] (当前日期和时间)的类型是 [LocalDateTime],所以 [today] 的类型将是 [LocalDateTime]。请注意,程序像在 Java 中一样调用了 Java 类的 [static] 方法:[LocalDateTime.now()];
  • 第 26–29 行:推断出的类型取决于字面量的写法:3.5 是 [Double],3.5F 是 [Float],10L 是 [Long];
  • 第 33 行:声明时没有初始值的变量;它的类型是必需的。虽然它被声明为 [val],但可以在之后(第 36 行)赋值,不过只能赋一次。Kotlin 不允许在一条语句中声明多个变量,而 Java 的 [int a = 1, b, c = 3;] 则可以:你需要每行写一个声明,或者用分号分隔多个声明,就像上一个程序那样;
  • 第 41 行:函数体只有一个表达式时,可以用等号(=)代替花括号和 表达式体来书写。你甚至可以省略返回类型,编译器会根据表达式推断出它。

[val] 变量不能被赋予新值,[var] 变量也不能改变其类型:其类型由声明确定。因此,下面的语句会被编译器拒绝:

1
2
3
4
5
6
val today = LocalDateTime.now()
today = LocalDateTime.now()
error: 'val' cannot be reassigned.
var counter = 0
counter = "one"
error: assignment type mismatch: actual type is 'String', but 'Int' was expected.

3.3.4. 空安全

有时能够表达值的 缺失 是有用的:未知的年龄、数据库中的空字段,或者未成功的搜索。在 Java 中,任何引用类型的变量都可以取值 [null],它表示“没有对象”。尝试访问这种变量的成员——例如它的 [length()] 方法——会导致运行时错误,即 [NullPointerException]:这是 Java 中最常见的错误,因为 Java 编译器不区分可以为 [null] 的引用和不可以为 null 的引用。为了在没有 [null] 的情况下表达值的缺失,Java 8 添加了 [Optional<T>] 类,这是一个要么包含值要么为空的“盒子”;而对于数字,Java 使用可以持有 [Integer] 的包装类 [null],而不是基本类型 [int]。

Kotlin 在类型系统本身中解决了这个问题,这是它的一大贡献。常规类型不允许 null 值:[String] 类型的变量总是包含一个字符串,[Int] 类型的变量总是包含一个整数。要允许 [null],必须在类型名称后面加上问号来明确表示:[String?] 是“字符串或 null”类型,[Int?] 是 “整数或 null”类型。这些被称为“可空类型”。于是,编译器会验证,在没有先处理 [null] 情况的前提下,不能使用可空值的成员:

1
2
3
4
5
6
7
val name: String = null
error: null cannot be a value of a non-null type 'String'.
val firstName: String? = firstNameOf("martin")
println(firstName.length)
error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'.
val n: Int = "12".toIntOrNull()
error: initializer type mismatch: expected 'Int', actual 'Int?'.

Kotlin 提供了几种使用可空值的方式:

  • [if (x != null)] 测试:在测试为真的分支中,编译器知道 [x] 不等于 [null],并把它当作 [String] 类型的值(而不是 [String?])。这被 称为“智能转换”;
  • 安全调用 [x?.length]:如果 [x] 等于 [null],表达式的值为 [null] 而不会导致错误;否则,其值为 [x.length]。因此结果的类型是 [Int?];
  • Elvis 运算符 [x ?: defaultValue]:它的值为 [x] ,当 [x] 不等于 [null] 时;否则为 [defaultValue] (其名称来自“?”符号与这位歌手侧面发型的相似之处)。它经常与安全调用结合使用:[x?.length ?: 0];
  • **let** 函数:***[x?.let { ... \\}] 仅当 *[x] 不等于 *[null]* 时才执行花括号之间的代码块;在代码块内,该值被称为 [it] ,其类型是非可空类型。该代码块是一个 lambda**,我们将在第 7 章学习这个概念;
  • 断言 [x!!]:程序员断言 [x] 不等于 [null]。如果这是真的,[x!!] 的类型就是 [String];否则,会抛出 [NullPointerException] 。应尽可能少用它:这是有意回到 Java 的行为。

?、?: 和 !! 运算符将在“空运算符”一节中更详细地讨论。C# 采用了类似的方法,即“可空引用类型”(C# 8),形式为警告;在 Kotlin 中,这些是编译错误。

实际上,[NullPointerException] 错误在 Kotlin 中很少见。现在它只会在少数情况下出现:使用 !!、显式抛出的异常,以及最主要的,使用 Java 代码。Kotlin 编译器不知道 Java 方法是否可能返回 [null]:因此它为其分配一个“平台类型”,在编译器消息中表示为 [String!] (不能在代码中书写),它可以作为 [String] 或 [String?] 使用。责任于是落在程序员身上。当已知某个 Java 方法会返回 [null] 时,把它的结果存储在可空变量中([val path: String? = System.getenv("X")]):编译器随后会恢复其检查。(带有 [@Nullable] 或 [@NonNull] 注解的 Java 方法——例如使用 JSpecify 项目的注解——会被分配特定的 Kotlin 类型,而不是平台类型。)

包装类和 [Optional] 会怎么样?[Int] 被编译为 [int],而 [Int?] 被编译为 [java.lang.Integer],因为只有引用才可以是 [null]:包装类仍然存在,但由编译器自行处理。[Optional] 类仍然可用,因为它是 Java 类,但在 Kotlin 中用处不大:[String?] 与 [Optional<String>] 表达的意思相同,却不会创建额外的对象,而且 ?. 和 ?: 运算符取代了它的 [map] 和 [orElse] 方法。Kotlin 库中可能什么也不返回的函数会返回 [null]:[toIntOrNull()]、[firstOrNull()]、[readlnOrNull()]……

从最初的示例起,我们就会遇到可空类型,因为读取键盘输入的一行的 [readlnOrNull()] 函数,在没有更多内容可读(输入流结束)时会返回 [null] 。程序 [Basics06.kt] 如下:

// 空安全
package basics06

// 可能不返回任何内容的函数:其结果类型为 String?
fun firstNameOf(name: String): String? = if (name == "dupont") "jean" else null

fun main() {
    // String 不能为 null;String? 可以
    val firstName1: String? = firstNameOf("dupont")
    val firstName2: String? = firstNameOf("martin")
    println("firstName1=$firstName1, firstName2=$firstName2, firstName2 is null: ${firstName2 == null}")
    // 测试之后,firstName1 的类型为 String:可以使用其 length 属性
    if (firstName1 != null) {
        println("firstName1 has ${firstName1.length} characters")
    }
    // 安全调用 ?. 在对象为 null 时返回 null
    println("lengths: ${firstName1?.length}, ${firstName2?.length}")
    // Elvis 运算符 ?: 提供替代值
    println("firstName2: ${firstName2 ?: "unknown"}, length: ${firstName2?.length ?: 0}")
    // let:仅当值不为 null 时才执行该块;在块内部,它被称为 it
    firstName1?.let { println("let: $it in upper case: ${it.uppercase()}") }
    firstName2?.let { println("this text is not displayed") }

    // Int? 由 java.lang.Integer 表示,Int 由 int 表示
    val age: Int? = "23".toIntOrNull()
    val unknownAge: Int? = "twenty".toIntOrNull()
    println("age=$age, unknownAge=$unknownAge, (unknownAge ?: 0) + 1 = ${(unknownAge ?: 0) + 1}")

    // !! 断言:"此值不为 null",否则抛出 NullPointerException
    println("firstName1!!.length=${firstName1!!.length}")
    try {
        println(firstName2!!.length)
    } catch (e: NullPointerException) {
        println("!! applied to null: ${e::class.qualifiedName}")
    }

    // Java 方法:编译器不知道结果是否可能为 null
    val path = System.getenv("UNKNOWN_VARIABLE")
    println("path=$path, length: ${path?.length}")
    try {
        // 编译器接受,但运行时会出现 NullPointerException
        println(path.length)
    } catch (e: NullPointerException) {
        println("path.length: ${e.message}")
    }

    // 如果输入流已关闭,readlnOrNull 返回 null
    print("Type a line: ")
    val line = readlnOrNull()
    if (line == null) {
        println()
        println("No line: the input stream is closed")
    } else {
        println("You typed [$line]: ${line.length} character(s)")
    }
}

通过键盘输入文本时的结果:

> gradlew -q run -Pmain=basics06.Basics06Kt
firstName1=jean, firstName2=null, firstName2 is null: true
firstName1 has 4 characters
lengths: 4, null
firstName2: unknown, length: 0
let: jean in upper case: JEAN
age=23, unknownAge=null, (unknownAge ?: 0) + 1 = 1
firstName1!!.length=4
!! applied to null: java.lang.NullPointerException
path=null, length: null
path.length: Cannot invoke "String.length()" because "path" is null
Type a line: hello
You typed [hello]: 5 character(s)

用户按下 Ctrl-D(在 Windows 上为 Ctrl-Z 后跟 Enter)关闭输入流时的结果:

> gradlew -q run -Pmain=basics06.Basics06Kt
firstName1=jean, firstName2=null, firstName2 is null: true
firstName1 has 4 characters
lengths: 4, null
firstName2: unknown, length: 0
let: jean in upper case: JEAN
age=23, unknownAge=null, (unknownAge ?: 0) + 1 = 1
firstName1!!.length=4
!! applied to null: java.lang.NullPointerException
path=null, length: null
path.length: Cannot invoke "String.length()" because "path" is null
Type a line:
No line: the input stream is closed

说明:

  • 第 5 行:返回名字的函数,名字也可能是 [null]。其结果的类型 [String?] 会告知使用者这一点。表达式 [if (...) "jean" else null] 是一个返回值的 [if];我们稍后会回到这一点;
  • 第 9–10 行:两个 [String?] 类型的变量。[firstName2] 等于 [null]。类型本来可以省略:它会根据 [firstNameOf] 结果的类型推断出来;
  • 第 11 行:模板对于 null 值显示 [null] ;使用 == 运算符测试 [null] 值;
  • 第 13–14 行:在 [if] 块内,[firstName1] 的类型是 [String]:可以安全地使用它的 [length] 属性(字符串的长度)。在块外,[firstName1.length] 会被拒绝;
  • 第 17 行:安全调用。[firstName2?.length] 等于 [null];
  • 第 19 行:Elvis 运算符。[firstName2 ?: "unknown"] 是 "unknown",而 [firstName2?.length ?: 0] 是 0;
  • 第 21–22 行:[let] 函数。第一个代码块在 [it] 被设为 "jean" 的情况下执行;第二个不执行;
  • 第 25–26 行:[toIntOrNull()] 函数把字符串转换为整数,如果字符串不表示整数,则返回 [null] 。[Int?] 类型被编译为 [java.lang.Integer];
  • 第 27 行:不能对 [Int?] 进行计算;[unknownAge + 1] 会被拒绝。Elvis 运算符返回 [Int]:如果 [unknownAge] 等于 [null],则为 0。因此,对 null 的 [Integer] 拆箱——Java 中的经典陷阱——是不可能发生的;
  • 第 30 行:!! 断言应用于非 null 值:它返回该值,类型为 [String];
  • 第 31–34 行:!! 断言应用于 *[null] 会抛出 *[NullPointerException]。捕获该错误的 [try / catch]* 结构将在后面介绍;这里显示异常的完整类名。[NullPointerException]* 是 Java 类,Kotlin 以相同的名称引用它;
  • 第 38 行:Java 方法 [System.getenv] 返回系统环境变量的值,如果它不存在则返回 [null] 。其结果是平台类型 [String!]:因此 [path] 属于这种类型;
  • 第 39 行:当作 [String?] 使用时,[path] 表现正确;
  • 第 42 行:当作 [String] 使用时,编译器接受它,但在运行时会引发 [NullPointerException] 。由 JVM 生成的异常消息(属性 [message])会准确指出哪个表达式是 [null]。如果我们写的是 [val path: String? = System.getenv(...)],编译器就会拒绝这一行;
  • 第 48 行:[print] 函数写到屏幕上,但不换行;用户输入将紧跟在消息之后;
  • 第 49 行:[readlnOrNull()] 函数读取键盘上输入的一行。它返回 [String?] 类型的值:如果输入流已关闭,则为 [null] ;
  • 第 50 行:检查 [null] 值;
  • 第 54 行:在 [else] 分支中,[line] 的类型是 [String]:可以安全地使用 [line.length]。

3.3.5. 数字与字符串之间的转换

转换
函数
数字 -> 字符串
[number.toString()]、类似 ["$number"] 的模板、["" + number],或类似 ["%d".format(number)] 的格式
字符串 -> int
[string.toInt()], [string.toIntOrNull()]
字符串 -> Long
[string.toLong()], [string.toLongOrNull()]
字符串 -> Double
[string.toDouble()], [string.toDoubleOrNull()]
字符串 -> Float
[string.toFloat()], [string.toFloatOrNull()]
字符串 -> BigDecimal
[string.toBigDecimal()], [string.toBigDecimalOrNull()]
字符串 -> Boolean
[string.toBoolean()], [string.toBooleanStrictOrNull()]

这些转换函数属于 Kotlin 库(包 [kotlin.text]),直接在字符串本身上调用:["10".toInt()] ,而不是 Java 函数 [Integer.parseInt("10")],后者仍然可用。它们是 扩展函数:写在 [String] 类之外,但调用方式与它的方法完全一样。我们将在第 4 章学习如何编写它们。

如果字符串不表示有效的数字,把字符串转换为数字可能失败。这时 [toInt()] 这样的函数会产生一种称为 异常的错误——此处的类型是 [NumberFormatException]——如果不处理,它会终止程序。可以用下面的 [try / catch] 子句来处理这个错误:

1
2
3
4
5
6
try {
    call of the function likely to throw the exception
} catch (e: NumberFormatException) {
    handle the exception e
}
next statement

如果函数没有抛出异常,执行就继续到下一条语句;否则,执行进入 [catch] 子句的主体,然后再到下一条语句。我们将在专门的一节中回到异常处理。

Kotlin 还为每种转换提供了一个不抛出异常的版本:[toIntOrNull()]、[toDoubleOrNull()]……在转换失败时返回 [null] 。它们的返回值是可空的([Int?]、[Double?]……):因此编译器要求处理失败的情况。与 Elvis 运算符结合使用时,它们允许你用一行写出带默认值的转换:[input.toIntOrNull() ?: 0]。Java 没有等价物;Java 课程编写了自己的方法,它返回 [OptionalInt]。

这些函数接受前导的 + 或 - 号,但不接受空格或千位分隔符:在转换之前,请使用 [trim()] 函数删除输入的前导和尾随空格。

程序 [Basics07.kt] 演示了数字与字符串之间转换的几种技术。[display] 函数在屏幕上显示其参数的值:

// 数字与字符串之间的转换
package basics07

import java.text.NumberFormat
import java.util.Locale

fun main() {
    // 数据
    val i = 10
    val l = 100000L
    val f = 45.78F
    val d = -14.98

    // 数字 → 字符串
    display(i.toString())
    display(l.toString())
    display("$f")
    display("" + d)

    // 布尔值 → 字符串
    val b = false
    display(b.toString())

    // 字符串 → Int
    var i1 = "10".toInt()
    display(i1.toString())
    try {
        i1 = "10.67".toInt()
        display(i1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // 字符串 → Long
    var l1 = "100".toLong()
    display(l1.toString())
    try {
        l1 = "10.675".toLong()
        display(l1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // 字符串 → Double:小数分隔符始终是点
    var d1 = "100.87".toDouble()
    display(d1.toString())
    try {
        d1 = "abcd".toDouble()
        display(d1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // 字符串 → Float
    var f1 = "100.87".toFloat()
    display(f1.toString())
    try {
        f1 = "100,87".toFloat()
        display(f1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // 字符串 → BigDecimal
    val m1 = "100.87".toBigDecimal()
    display(m1.toString())

    // 字符串 → Boolean
    display("${"true".toBoolean()} ${"yes".toBoolean()} ${"yes".toBooleanStrictOrNull()}")

    // 不抛异常的转换:xxxOrNull 函数在失败时返回 null
    val i2 = "123".toIntOrNull()
    if (i2 != null) {
        display("\"123\".toIntOrNull() succeeded: $i2")
    }
    val i3 = "12x".toIntOrNull()
    if (i3 == null) {
        display("\"12x\".toIntOrNull() failed")
    }
    display("with a default value: ${"12x".toIntOrNull() ?: -1}")
    // 不接受空格:用 trim() 去除
    display("[ 42 ] : ${" 42 ".toIntOrNull()}, ${" 42 ".trim().toIntOrNull()}")

    // 用户的语言("locale")仅在格式方面起作用
    display("Current locale: ${Locale.getDefault().toLanguageTag()}")
    display("%.2f".format(d1))
    display("%.2f".format(Locale.ROOT, d1))
    // 读取法式写法的数字:Java 的 NumberFormat 类
    // parse 可能抛出 ParseException:Kotlin 不强制我们处理它
    val number = NumberFormat.getInstance(Locale.FRANCE).parse("100,87")
    display("NumberFormat: ${number.toDouble()}")
}

// 显示其参数的函数
fun display(s: String) {
    println("S=$s")
}

结果:

> gradlew -q run -Pmain=basics07.Basics07Kt
S=10
S=100000
S=45.78
S=-14.98
S=false
S=10
S=Error: For input string: "10.67"
S=100
S=Error: For input string: "10.675"
S=100.87
S=Error: For input string: "abcd"
S=100.87
S=Error: For input string: "100,87"
S=100.87
S=true false null
S="123".toIntOrNull() succeeded: 123
S="12x".toIntOrNull() failed
S=with a default value: -1
S=[ 42 ] : null, 42
S=Current locale: fr-FR
S=100,87
S=100.87
S=NumberFormat: 100.87

说明:

  • 第 9–12 行:要转换的数据;
  • 第 15–18 行:把数字转换为字符串的四种方式。第三种使用模板,最后一种把空字符串与数字拼接。模板是 Kotlin 中最常用的方法;
  • 第 22 行:布尔值显示为 [true] 或 [false];
  • 第 25–31 行:我们处理 [toInt()] 可能抛出的异常。变量 [i1] 用 [var] 声明,因为它在 [try] 中接收新值。[e.message] 是与 [e] 异常关联的错误消息(Java 方法 [getMessage()],在 Kotlin 中被视为属性)。这些是由 Kotlin 函数所调用的 Java 方法给出的消息:它们是英文的;
  • 第 45 行:[toDouble()] 始终期望小数点,与用户的语言无关:字符串 "100.87" 在所有机器上的解释都相同。这是从文件中读取数字或在程序之间交换数字的正确方式;
  • 第 58 行:因此,小数逗号会被拒绝;
  • 第 65 行:把字符串转换为 [BigDecimal];这同样期望小数点。它等价于 [BigDecimal("100.87")];
  • 第 69 行:对于字符串 "true"(不区分大小写),[toBoolean()] 返回 [true] ,对于任何其他字符串(包括 "yes")则返回 [false] 。[toBooleanStrictOrNull()] 只接受“true”和“false”,对其他所有内容返回 [null] ;
  • 第 72–78 行:不抛出异常的转换。[i2] 和 [i3] 与 [Int?] 类型相同;在 [i2 != null] 测试之后,[i2] 可以当作 [Int] 使用。在字符串中,引号写作 \";
  • 第 80 行:使用 Elvis 运算符进行带默认值的转换。模板包含一个字符串 "12x",它本身用引号括起来:这在花括号内是允许的;
  • 第 82 行:" 42 " 不会被转换;在 [trim()] 之后,它就会被转换;
  • 第 85 行:[Locale.getDefault()] 返回程序的 区域设置——即源自系统设置的用户语言和国家:这里是 fr-FR;
  • 第 86 行:格式使用当前区域设置:实数用小数逗号书写;
  • 第 87 行:[format] 函数接受区域设置作为第一个参数。[Locale.ROOT] 是一种中性区域设置,无论机器如何,都使用句点作为小数分隔符。它用于把格式化的数字写入文件或在程序之间交换,这类场景不得依赖于用户的语言;
  • 第 90 行:要读取按法语约定书写的数字,请使用 [NumberFormat] 对象(来自 JDK 的 [java.text] 包),该对象针对 [Locale.FRANCE] 区域设置获得。它的 [parse] 方法返回 [Number] 对象,并且可能抛出 [ParseException] 异常。在 Java 中,这是一个 受检 异常:编译器要求处理它。Kotlin 没有受检异常:编译器把是否处理异常交给程序员决定。我们将在异常一节回到这一点;
  • 第 91 行:[toDouble()] 把 [Number] 转换为 [Double];
  • 第 95–96 行:顶层函数。函数可以按任意顺序编写,放在 [main] 之前或之后均可。它不返回结果:省略了返回类型(它实际上是 [Unit] 类型,相当于 Java 的 [void])。

请注意,[toInt()]、[toDouble()]……和 [toString()] 函数忽略用户的语言(使用小数点),而格式和 [NumberFormat] 类则遵循它。读取数字的程序必须始终知道这些数字是按哪种约定书写的。

3.3.6. 数据数组

Kotlin 数组是一个对象,它允许把相同类型的数据归入单个标识符之下。Kotlin 区分两种数组类型:

  • 泛型类型 [Array<T>],即 [T] 类型元素的数组:[Array<String>] 是字符串数组。它对应于 Java 的 [T[]] 对象数组([String[]]);
  • 针对基本类型的专用类型:[IntArray]、[LongArray]、[DoubleArray]、[BooleanArray]、[CharArray]……[IntArray] 对应于 Java 数组 [int[]]:它的元素是基本类型值,在内存中并排排列。你也可以写 [Array<Int>],但那会是 [Integer] ([Integer[]])对象的数组,更占空间也更慢:对于数字,应优先使用专用数组。

创建数组有几种方式:

1
2
3
4
5
val t1 = arrayOf("a", "b", "c")         // initialized Array<String>
val t2 = intArrayOf(0, 10, 20, 30)      // initialized IntArray
val t3 = IntArray(n)                    // n integers equal to 0
val t4 = Array(n) { i -> value }        // n elements, computed from their index
val t5 = arrayOfNulls<String>(n)        // Array<String?> of n elements equal to null

Kotlin 没有用于创建数组的 [new] 运算符或 [{0, 10, 20\}] 语法:一切都通过函数([arrayOf]、[intArrayOf]……)或构造函数([IntArray(n)]、[Array(n) { ... \}])完成。[IntArray(n)] 包含 n 个零,而 [BooleanArray(n)] 包含 n 个 [false] 值。然而,不存在 [Array<String>(n)] 这样元素为 [null] 的数组:这会违反空安全,因为元素的类型是 [String]。你必须要么指定每个元素的值,要么使用 [arrayOfNulls<String>(n)] 显式请求元素可空的数组,其类型为 [Array<String?>]。

数组中的元素个数是它的 [size] 属性(即 Java 字段 [length])。语法 [array[i]] 指第 i 个数据项,其中 i 属于区间 [0, size-1]。任何对 [array[i]] 数据的引用,只要 i 不在此范围内,就会导致 [ArrayIndexOutOfBoundsException] 异常。[indices] 属性是有效索引的范围(从 0 到 size-1),而 [lastIndex] 是最后一个索引(size-1)。数组在创建之后不能改变大小:对于会增长的集合,要使用列表(第 5 章)。引用数组的 [val] 变量不能再引用另一个数组,但数组的元素仍然可以修改。

Kotlin 也没有真正的二维数组:带有两个索引的数组是 数组的数组,例如 [Array<DoubleArray>]。语法 [array[i][j]] 指第 i 行的第 j 个元素。[array.size] 是行数,而 [array[i].size] 是 第 i 行的元素个数。由于每一行都是独立的数组,各行可以有不同的长度(这被称为 “阶梯数组”)。

Kotlin 库提供了丰富的数组函数,它们取代了 [java.util.Arrays] 类的方法,并远远超出了这些方法:[contentToString()]、[contentDeepToString()]、[contentEquals()]、[first()]、[last()]、[getOrNull(i)]、[copyOf()]、[copyOfRange(start, end)], [sliceArray(range)]、[sort()]、[sorted()]、[fill()]、[sum()]、[max()]、[average()]、[contains()] (用运算符 [in] 书写)……它们大多与列表中的相同,我们将在第 5 章中研究。

程序 [Basics08.kt] 综合运用了这些不同的数组:

// 数组
package basics08

fun main() {
    // 已初始化的整数数组:IntArray(即 Java 的 int[])
    val integers = intArrayOf(0, 10, 20, 30)
    for (i in integers.indices) {
        println("integers[$i]=${integers[i]}")
    }

    // 二维数组:由等长数组组成的数组
    val reals = arrayOf(doubleArrayOf(0.5, 1.7), doubleArrayOf(8.4, -6.0))
    for (i in reals.indices) {
        for (j in reals[i].indices) {
            println("reals[$i][$j]=${reals[i][j]}")
        }
    }
    println("reals=${reals.contentDeepToString()}")

    // 由不等长数组组成的数组(锯齿数组)
    // Array(n) { i -> ... } 根据索引计算每个元素的值
    val names = Array(3) { i -> Array(i + 1) { j -> "name$i$j" } }
    for (i in names.indices) {
        for (j in names[i].indices) {
            println("names[$i][$j]=${names[i][j]}")
        }
    }

    // 不带初始值创建的数组
    val flags = BooleanArray(3)
    val strings = arrayOfNulls<String>(2)
    println("flags[0]=${flags[0]}, strings[0] is null: ${strings[0] == null}")

    val values = intArrayOf(0, 10, 20, 30, 40)
    // contentToString 用数组的元素构建字符串
    println("values=${values.contentToString()}, size=${values.size}, lastIndex=${values.lastIndex}")
    // 第一个、最后一个和倒数第二个元素
    println("first=${values.first()}, last=${values.last()}")
    println("second-to-last=${values[values.size - 2]}, ${values[values.lastIndex - 1]}")
    // 数组的一部分:索引 1 和 2 处的元素(不包含结束边界)
    val extract = values.copyOfRange(1, 3)
    println("copyOfRange(1, 3)=${extract.contentToString()}")
    // 索引 2 到 lastIndex 的元素(闭区间)
    val end = values.sliceArray(2..values.lastIndex)
    println("sliceArray(2..lastIndex)=${end.contentToString()}")
    // 提取的结果是副本:原数组不会被修改
    extract[0] = 100
    println("extract[0]=${extract[0]}, values[1]=${values[1]}")
    // Kotlin 库的一些函数
    println("sum=${values.sum()}, max=${values.max()}, average=${values.average()}")
    println("20 in values: ${20 in values}, 25 in values: ${25 in values}")

    // 对象数组:Array<String>
    val friends = arrayOf("paul", "hélène", "jacques")
    println("first friend=${friends.first()}, last friend=${friends.last()}, friends.getOrNull(5)=${friends.getOrNull(5)}")
    // 超出数组边界的索引
    try {
        println(friends[3])
    } catch (e: ArrayIndexOutOfBoundsException) {
        println("friends[3]: ${e.message}")
    }
}

结果:

> gradlew -q run -Pmain=basics08.Basics08Kt
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0][0]=0.5
reals[0][1]=1.7
reals[1][0]=8.4
reals[1][1]=-6.0
reals=[[0.5, 1.7], [8.4, -6.0]]
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=false, strings[0] is null: true
values=[0, 10, 20, 30, 40], size=5, lastIndex=4
first=0, last=40
second-to-last=30, 30
copyOfRange(1, 3)=[10, 20]
sliceArray(2..lastIndex)=[20, 30, 40]
extract[0]=100, values[1]=10
sum=100, max=40, average=20.0
20 in values: true, 25 in values: false
first friend=paul, last friend=jacques, friends.getOrNull(5)=null
friends[3]: Index 3 out of bounds for length 3

说明:

  • 第 6 行:已初始化的整数数组,类型为 [IntArray];
  • 第 7 行:[for] 类型的循环遍历数组索引,从 0 到 [integers.lastIndex]。[for] 循环将在后面介绍;
  • 第 8 行:在模板中,[$i] 是索引值,[${integers[i]\}] 是元素值。表达式 [integers[i]] 需要花括号;跟在 [[$i] 后面的方括号则不需要,因为它不可能是变量名的一部分;
  • 第 12 行:二维数组(2 行 2 列),类型为 [Array<DoubleArray>]。必须写 -6.0 而不是 -6:[doubleArrayOf] 函数期望 [Double],而 Kotlin 不会把整数 -6 转换为浮点数(Java 会);
  • 第 13–14 行:[reals.indices] 遍历各行,[reals[i].indices] 遍历 第 i 行的各列;
  • 第 18 行:[contentDeepToString()] 显示数组的数组;
  • 第 22 行:3 行的阶梯数组。[Array(3) { i -> ... \}] 构造函数创建一个有 3 个元素的数组,并通过以元素的索引 [i] 执行花括号之间的代码块来计算每个元素的值。这里的每个元素本身又是一个字符串数组([i + 1]),其索引为 [j] 的元素是 "name" 后接 i 和 j。花括号之间的代码块是一个 lambda(第 7 章);现在只需把它读作“对于索引 i,值是……”即可。在 Java 中,这需要三个步骤:创建行数组、创建每一行,然后填充元素;
  • 第 30 行:3 个布尔值的数组,全部为 [false];
  • 第 31 行:2 个可空字符串的数组,全部为 [null];
  • 第 36 行:[contentToString()] 函数用数组的元素构造字符串。如果直接显示数组([println(values)]),就会像在 Java 中一样得到形如 [I@6328d34a 的文本(数组类型和一个数字代码),而不是它的内容;
  • 第 38–39 行:第一个、最后一个和倒数第二个元素。[first()] 和 [last()] 函数取代了表达式 [values[0]] 和 [values[values.size - 1]]。Kotlin 没有从数组末尾开始计数的索引(相当于 C# 的 [^1]);
  • 第 41 行:索引为 1 和 2 的元素。与 Java 中的 [Arrays.copyOfRange] 一样,结束边界不包含在内;
  • 第 44 行:索引从 2 到 [lastIndex] 的元素。[2..values.lastIndex] 是一个区间:从 2 到 4 的整数集合,包含两端。[sliceArray] 函数返回一个新数组,由索引属于该区间的元素组成。区间将在介绍 [for] 循环时引入;
  • 第 47–48 行:[copyOfRange] 创建一个副本;修改 [extract] 不会修改 [values];
  • 第 50 行:元素的总和、最大值和平均值。平均值是 [Double];
  • 第 51 行:[in] 运算符检查某个值是否存在于数组中;
  • 第 54 行:对象数组,类型为 [Array<String>];
  • 第 55 行:当索引越界时,[friends.getOrNull(5)] 返回 [null] 而不是抛出异常;
  • 第 58–60 行:索引 3 不存在:抛出 [ArrayIndexOutOfBoundsException] ,其消息指出了错误的索引和数组大小。

3.4. Kotlin 的基本语句

有两种类型:

  • 由计算机执行的基本指令;
  • 控制程序流程的指令。

考虑微型计算机及其外围设备的结构时,基本指令就变得清晰了:

Image

  • 1:从键盘读取信息;
  • 2:处理信息;
  • 3:把信息写到屏幕。

3.4.1. 写到屏幕

有各种向屏幕写入的指令:

1
2
3
4
println(expression)
print(expression)
System.out.println(expression)
System.err.println(expression)

其中 [expression] 是任何可以转换为字符串以显示在屏幕上的数据。所有对象都有 [toString()] 方法,用于执行这种转换。[println] 函数写出值然后换到下一行;[print] 函数做同样的事情,但不换行;不带任何参数的 [println()] 只是换到下一行。对于格式化输出,请使用 [println("format".format(value1, ...))],或者使用 Java 方法 [System.out.printf(format, value1, ...)]。

Kotlin 的 [println] 和 [print] 函数(位于 [kotlin.io] 包中)写入 Java 流 [System.out]。[System] 类通过其静态字段 [out] 和 [err] 提供对两个写入流的访问,它们的类型是 [PrintStream]:

  • [System.out.println()] 写入 [out] 流,即 标准输出,它通常与屏幕关联;
  • [System.err.println()] 写入 [err] 流,即 错误输出,它通常也与屏幕关联。

Kotlin 库没有写入错误输出的函数:直接使用 [System.err.println]。[out] 和 [err] 流可以在运行时重定向到文件,我们稍后会看到。

3.4.2. 读取从键盘输入的数据

来自键盘的数据流由 Java 字段 [System.in] 表示,其类型是 [InputStream]。这是一个字节流,直接使用不太方便。Kotlin 库提供了两个从该流读取一行文本的函数:

val line: String = readln()
val line: String? = readlnOrNull()

在键盘上输入的行(不含行结束符)存储在变量 [line] 中,然后可由程序处理。这两个函数只在输入流结束时的行为上有所不同(当用户按下 Ctrl-D,或在 Windows 上按 Ctrl-Z 后跟 Enter,或者重定向到输入流的文件已读完时):

  • [readln()] 此时抛出 [ReadAfterEOFException] 异常;因此它总是返回 [String] 类型的字符串;
  • [readlnOrNull()] 此时返回 [null];其结果的类型是 [String?],这要求处理这种情况,就像程序 [Basics06.kt] 所做的那样。

这些函数不显示提示:提示事先用 [print] 指定。在较旧的程序中,你可能还会遇到 [readLine()] 函数,它的行为与 [readlnOrNull()] 相同,还有 Java 类 [BufferedReader] 和 [Scanner],它们仍然可用。[System.in] 流可以像 [out] 和 [err] 流一样重定向到文件。最后,请注意 Java 类 [Console],它由 [System.console()] 得到,其 [readPassword] 方法读取密码而不显示它。

3.4.3. 输入/输出示例

程序 [Basics09.kt] 演示了键盘和屏幕的输入/输出操作:

// 键盘 / 屏幕输入输出
package basics09

fun main() {
    // 写入 System.out 流
    val obj = Any()
    println(obj)

    // 写入 System.err 流
    val i = 10
    System.err.println("i=$i")
    System.err.printf("i=%d%n", i)

    // 显示提示后,读取键盘输入的一行
    print("Type a line: ")
    val line = readln()
    println("line=$line")
}

结果:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics09.Basics09Kt
java.lang.Object@2b2fa4f7
i=10
i=10
Type a line: here I am
line=here I am

说明:

  • 第 6 行:[obj] 是对 [Any] 类对象的引用,该类是所有 Kotlin 类的根类(Java 中的 [Object] )。对象通过调用 [Any()] 构造函数创建,不使用 [new];
  • 第 7 行:[obj] 被打印到屏幕上。调用 [obj.toString()] 方法来获取要显示的文本;
  • 第 11 行:[err] 被写入流;
  • 第 12 行:同样的事情,但使用了格式。第一个参数 "i=%d%n," 是显示格式;其他参数是要显示的值:%d 被替换为 [i] 的值,%n 被替换为系统的行结束符(Windows 上是 \r\n,Linux 和 macOS 上是 \n);
  • 第 15 行:显示提示而不换行;
  • 第 16 行:读取在键盘上输入的行。[line] 的类型是 [String]。

在结果中:

  • 第 2 行:代码第 7 行生成的输出。[toString()] 方法在 [Any] 类中返回对象的完整类名,后面跟着 @ 字符和一个十六进制数字代码(它的“哈希码”),每次执行或每台机器上可能不同。我们可以看到,Kotlin 类 *[Any]* 在运行时确实就是类 *[java.lang.Object]*。类通常会重写这个方法以显示更有用的内容,我们将在第 4 章这样做;
  • 第 3–4 行:对 [err] 流的两次写入与对 [out] 流的写入一样显示在屏幕上。

如果用户关闭输入流而不是输入一行,[readln()] 就会抛出异常,从而终止程序:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics09.Basics09Kt
java.lang.Object@2b2fa4f7
i=10
i=10
Type a line: Exception in thread "main" kotlin.io.ReadAfterEOFException: EOF has already been reached
    at kotlin.io.ConsoleKt.readln(Console.kt:152)
    at basics09.Basics09Kt.main(Basics09.kt:16)
    at basics09.Basics09Kt.main(Basics09.kt)

异常消息之后是 调用栈 (“stack trace”):出错时正在执行的函数列表,最近的在最上面,并附有每个函数的文件和行号。它表明 [readln] 函数(来自 Kotlin 库的文件 [Console.kt] )在文件 [Basics09.kt] 的第 16 行被调用,经由 [main] 方法,该方法属于 [Basics09Kt] 类,而该类本身又由编译器生成的 [main(String[])] 方法调用。(使用 [gradlew run] 时,Gradle 还会报告 [run] 任务失败;此处没有重现其消息。)

3.4.4. I/O 重定向

Windows、Linux 和 macOS 识别三种标准设备:

  • 标准输入设备,默认指键盘,编号为 0;
  • 标准输出设备,默认指屏幕,编号为 1;
  • 标准错误设备,默认指屏幕,编号为 2。

在 JVM 上,写入流 [System.out] (与 [println] 和 [print] 函数相关联)写入设备 1,写入流 [System.err] 写入设备 2,而读取流 [System.in](与 [readln] 和 [readlnOrNull] 函数相关联)从设备 0 读取数据。

在命令窗口中运行程序时,可以指定对被执行的程序而言哪些设备是 0、1 和 2。在程序参数之后,可以把标准输入/输出设备重定向到文件:

重定向
含义
0<in.txt or <in.txt
标准输入流 0 号被重定向到文件 in.txt。因此在程序中,[System.in] 流将从文件 in.txt 读取数据
1>out.txt or >out.txt
把 1 号输出重定向到文件 out.txt。因此在程序中,[System.out] 流将把数据写入文件 out.txt
1>>out.txt or >>out.txt
与上面相同,但写入的数据追加到文件 out.txt 的当前内容之后
2>err.txt
把 2 号输出重定向到文件 err.txt。因此在程序中,[System.err] 流将把数据写入文件 err.txt
2>>err.txt
与上面相同,但写入的数据追加到文件 err.txt 的当前内容之后
1>out.txt 2>err.txt
设备 1 和 2 都被重定向到文件

请注意,要把程序的输入/输出流重定向到文件,无需修改程序:设备 0、1 和 2 的性质由操作系统决定。考虑下面的程序 [Basics10.kt]:

// 输入输出流的重定向
package basics10

fun main() {
    // 读取 System.in 流
    val data = readln()
    // 写入 System.out 流
    println("writing to the out stream: $data")
    // 写入 System.err 流
    System.err.println("writing to the err stream: $data")
}

重定向作用于在提示符下输入的命令所启动的程序。对于 ***[gradlew run]***,这个程序就是 Gradle 本身,它再把流传递给 Kotlin 程序:重定向通常有效,但文件也可能收到来自 Gradle 的消息(警告、编译错误等)。要单独观察程序的行为,最好在 Gradle 之外运行它。正如我们在第 2 章中看到的,[installDist] 任务会在 [build/install/basics] 文件夹(其名称 [basics], 由文件 [settings.gradle.kts] 设定)中准备项目的可安装版本:其中有一个名为 [lib] 的文件夹,包含项目的类归档和 Kotlin 标准库,以及一个名为 [bin] 的文件夹,包含启动脚本 [basics](Linux、macOS)和 [basics.bat] (Windows)。脚本启动的是创建它时由文件 [build.gradle.kts] 指定的类;因此,程序是通过 [installDist] 命令选定的:

> gradlew -q installDist -Pmain=basics10.Basics10Kt

下面是在项目文件夹中的 Linux 终端(bash)会话:

> echo test > in.txt
> cat in.txt
test
> build/install/basics/bin/basics < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the out stream: test
> cat err.txt
writing to the err stream: test
> build/install/basics/bin/basics < in.txt 2> err.txt
writing to the out stream: test
> build/install/basics/bin/basics < in.txt > out.txt
writing to the err stream: test

说明:

  • 第 1 行:我们把字符串 "test" 写入文件 in.txt;
  • 第 2 行:显示文件 in.txt 的内容以便验证;
  • 第 4 行:运行程序。[System.in] 流被重定向到文件 in.txt,[System.out] 流被重定向到文件 out.txt,[System.err] 流被重定向到文件 err.txt。执行时没有任何输出;
  • 第 5–6 行:文件 out.txt 的内容表明,文件 in.txt 已被读取,并且对 [out] 流的写入已被重定向到 out.txt;
  • 第 7–8 行:对文件 err.txt 的类似验证;
  • 第 9–10 行:只有 [err] 流被重定向:屏幕上只显示对 [out] 流的写入操作;
  • 第 11–12 行:只有 [out] 流被重定向:屏幕上只显示对 [err] 流的写入操作。

很明显,[out] 和 [err] 流并不写入同一设备,因为它们可以被分别重定向。[err] 流用于错误消息:这样你就可以把程序的输出重定向到文件,同时仍然在屏幕上看到它的错误消息。

运算符 >、>> 和 2> 在 Windows 命令提示符([cmd])、PowerShell 和 bash 中的写法相同。< 运算符被 [cmd] 和 bash 识别,但 PowerShell 不识别,它 把它保留给将来使用:在 PowerShell 中,要把文件送到程序的标准输入,需要使用管道(|)。下面这些命令仅作说明之用(本课程中没有执行过),它们在 Windows 上完成上述 bash 会话所做的事情:

rem Windows command prompt (cmd)
echo test>in.txt
build\install\basics\bin\basics <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | build\install\basics\bin\basics > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

3.4.5. 把表达式的值赋给变量

这里我们关注的是 [variable = expression] 操作。表达式可以是算术、关系、布尔、字符串等类型。

3.4.5.1. 赋值操作的解释

操作 [variable = expression] 按如下方式进行:

  • 计算赋值号右侧:结果是一个值 V;
  • 把值 V 赋给变量。

在 Java 中,与 C 和 C# 一样,赋值本身就是一个表达式,其值为 V:因此我们可以写 [V1 = V2 = expression],它把表达式的值先赋给 V2 再赋给 V1,或者写 [if ((n = read()) > 0)],它同时完成赋值和求值。在 Kotlin 中,赋值是语句,而不是表达式:它没有值,也不能出现在需要值的地方。因此编译器会拒绝:

1
2
3
var v2 = 0
val v1 = (v2 = 7 * 6)
error: only expressions are allowed in this context.

像 [V1 = V2 = expression] 这样的多重赋值出于同样的原因被拒绝:它们涉及书写两个赋值。这一选择消除了 C 和 Java 中常见的错误来源:在 [if (x = 0)] 这样的测试中混淆赋值运算符 = 和比较运算符 == 变得不可能。

3.4.5.2. 算术表达式

算术表达式中使用的运算符如下:

运算符
作用
+
加法
-
减法
*
乘法
/
除法:如果至少有一个操作数是实数,结果是精确的商。如果两个操作数都是整数,结果是整数商。因此,5/2 等于 2,5.0/2 等于 2.5
%
除法的余数,与操作数的类型无关。余数的符号与被除数相同:-5 % 2 等于 -1。% 运算符是函数 [rem] (“remainder”)的另一种写法:[a % b] 等价于 [a.rem(b)]。[mod] 函数返回数学意义上的 余数,符号与除数相同:[(-5).mod(2)] 等于 1

在 Kotlin 中,所有这些运算符实际上都是书写函数的另一种方式:[a + b] 等价于 [a.plus(b)],[a - b] 等价于 [a.minus(b)],[a * b] 等价于 [a.times(b)],而 [a / b] 等价于 [a.div(b)]。当然,编译器会把针对基本类型的这些操作翻译成 JVM 的算术指令,而不进行任何函数调用。不过,这一机制允许为其他类配备这些运算符(运算符重载,第 4 章);Kotlin 库特别为 Java 类 [BigDecimal] 做了这件事。

有各种数学函数。Kotlin 把它们归入 [kotlin.math] 包,必须导入它([import kotlin.math.*] 或 [import kotlin.math.sqrt]……)。下面是其中的一些:

函数
作用
[sqrt(x)]
平方根
[cos(x)], [sin(x)], [tan(x)]
余弦、正弦、正切(角度以弧度为单位)
[x.pow(y)]
x 的 y 次幂(y 是实数或整数)
[exp(x)]
指数
[ln(x)], [log10(x)], [log(x, base)]
自然对数、常用对数、任意底数的对数
[abs(x)] 或 [x.absoluteValue], [max(x, y)], [min(x, y)]
绝对值、最大值、最小值(适用于 Int、Long、Float、Double 类型)
[floor(x)], [ceil(x)], [truncate(x)]
向下取整、向上取整、向零截断
[x.roundToInt()], [x.roundToLong()]
四舍五入到最接近的整数,恰好居中的值向上舍入
[round(x)]
四舍五入到最接近的整数,恰好居中的值舍入到最接近的偶数(实数结果)
[x.coerceIn(min, max)]
映射到区间 [min, max] 的值
[PI], [E]
常数 π 和 e

它们是顶层函数(或者像 [pow] 和 [roundToInt] 那样,是在数字本身上调用的扩展函数):调用它们时不带前缀。因此,我们这样写:

    val y = 4.0
    val x = sqrt(y)

Java 类 [Math] 的静态方法([Math.sqrt(y)]、[Math.floorMod(-5, 2)]……)仍然可以使用,无需导入,因为 [Math] 属于 [java.lang] 包。[kotlin.math] 包的完整说明可以在 Kotlin 在线文档中找到,网址为 kotlinlang.org/api/core/kotlin-stdlib/kotlin.math/。

[Double] 类型的实数 以二进制格式存储:大多数十进制数,例如 0.1,只是近似值。这对科学计算无关紧要,但对金额而言是不可接受的。另一方面,[BigDecimal] 类(位于 JDK 的 [java.math] 包中)精确地表示十进制数,位数不限。在 Java 中,计算使用这些方法进行:[add]、[subtract]、[multiply]、[divide]……在 Kotlin 中,这些方法仍然可用,但标准库为该类添加了 +、-、*、/、% 运算符和一元 - 运算符:你写 [a + b] 而不是 [a.add(b)]。它还添加了转换函数 ["0.1".toBigDecimal()] 和 [3.toBigDecimal()]。[BigDecimal] 是 不可变的:操作不会修改被应用的对象,而是返回一个新对象。

程序 [Basics11.kt] 如下:

// 算术表达式
package basics11

import java.math.BigDecimal
import java.math.MathContext
import java.math.RoundingMode
import kotlin.math.*

fun main() {
    // 整数除法和实数除法
    println("5 / 2 = ${5 / 2}, 5.0 / 2 = ${5.0 / 2}, 5 / 2.0 = ${5 / 2.0}")
    // 除法的余数:% 运算符(rem 函数)和 mod 函数
    println("5 % 2 = ${5 % 2}, -5 % 2 = ${-5 % 2}, 5.5 % 2 = ${5.5 % 2}")
    println("(-5).rem(2) = ${(-5).rem(2)}, (-5).mod(2) = ${(-5).mod(2)}")
    // 实数除以零:不报错,结果为无穷大或 NaN(Not a Number)
    val zero = 0.0
    println("1 / 0.0 = ${1 / zero}, 0 / 0.0 = ${0 / zero}")
    // 整数除以零:抛出异常
    val integerZero = "0".toInt()
    try {
        println(1 / integerZero)
    } catch (e: ArithmeticException) {
        println("1 / 0 : ${e::class.simpleName} - ${e.message}")
    }

    // kotlin.math 包的一些函数
    val y = 4.0
    val x = sqrt(y)
    println("sqrt(4.0) = $x")
    println("2.0.pow(10) = ${2.0.pow(10)}, 2.0.pow(0.5) = ${2.0.pow(0.5)}")
    println("abs(-3.5) = ${abs(-3.5)}, max(3, 7) = ${max(3, 7)}, (-7).absoluteValue = ${(-7).absoluteValue}")
    println("PI = $PI, cos(PI) = ${cos(PI)}")
    println("exp(1.0) = ${exp(1.0)}, ln(E) = ${ln(E)}, log10(1000.0) = ${log10(1000.0)}")
    println("floor(-2.5) = ${floor(-2.5)}, ceil(-2.5) = ${ceil(-2.5)}, truncate(-2.5) = ${truncate(-2.5)}")
    // roundToInt 四舍五入到最接近的整数,一半向上取整;返回 Int
    println("2.5.roundToInt() = ${2.5.roundToInt()}, (-2.5).roundToInt() = ${(-2.5).roundToInt()}")
    // round 将一半取整到最接近的偶数;返回 Double
    println("round(2.5) = ${round(2.5)}, round(3.5) = ${round(3.5)}")
    // coerceIn 将值限制回某个范围内
    println("150.coerceIn(0, 100) = ${150.coerceIn(0, 100)}")
    // Java 的 Math 类的方法仍然可用
    println("Math.sqrt(4.0) = ${Math.sqrt(4.0)}, Math.round(2.5) = ${Math.round(2.5)}")

    // 优先级:* / % 先于 + -
    println("2 + 3 * 4 = ${2 + 3 * 4}, (2 + 3) * 4 = ${(2 + 3) * 4}")
    println("10 - 4 - 3 = ${10 - 4 - 3}, \"x\" + 1 + 2 = ${"x" + 1 + 2}")

    // Double 实数是二进制近似值
    println("0.1 + 0.2 = ${0.1 + 0.2}")
    // BigDecimal 以 10 为基数精确计算,使用 + - * / 运算符
    val a = BigDecimal("0.1")
    val b = "0.2".toBigDecimal()
    println("BigDecimal : 0.1 + 0.2 = ${a + b}")
    val price = BigDecimal("19.99")
    val total = price * 3.toBigDecimal()
    println("3 x 19.99 = $total, with VAT = ${total * BigDecimal("1.2")}")
    // 四舍五入到 2 位小数,一半向上取整(商业舍入)
    println("2.565 rounded = ${BigDecimal("2.565").setScale(2, RoundingMode.HALF_UP)}")
    // / 运算符保留被除数的小数位数
    val three = 3.toBigDecimal()
    println("10 / 3 = ${BigDecimal.TEN / three}, 10.00 / 3 = ${BigDecimal("10.00") / three}")
    // 带精度的 divide 方法
    println("10 / 3 = ${BigDecimal.TEN.divide(three, MathContext.DECIMAL64)}")
}

结果:

> gradlew -q run -Pmain=basics11.Basics11Kt
5 / 2 = 2, 5.0 / 2 = 2.5, 5 / 2.0 = 2.5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1.5
(-5).rem(2) = -1, (-5).mod(2) = 1
1 / 0.0 = Infinity, 0 / 0.0 = NaN
1 / 0 : ArithmeticException - / by zero
sqrt(4.0) = 2.0
2.0.pow(10) = 1024.0, 2.0.pow(0.5) = 1.4142135623730951
abs(-3.5) = 3.5, max(3, 7) = 7, (-7).absoluteValue = 7
PI = 3.141592653589793, cos(PI) = -1.0
exp(1.0) = 2.718281828459045, ln(E) = 1.0, log10(1000.0) = 3.0
floor(-2.5) = -3.0, ceil(-2.5) = -2.0, truncate(-2.5) = -2.0
2.5.roundToInt() = 3, (-2.5).roundToInt() = -2
round(2.5) = 2.0, round(3.5) = 4.0
150.coerceIn(0, 100) = 100
Math.sqrt(4.0) = 2.0, Math.round(2.5) = 3
2 + 3 * 4 = 14, (2 + 3) * 4 = 20
10 - 4 - 3 = 3, "x" + 1 + 2 = x12
0.1 + 0.2 = 0.30000000000000004
BigDecimal : 0.1 + 0.2 = 0.3
3 x 19.99 = 59.97, with VAT = 71.964
2.565 rounded = 2.57
10 / 3 = 3, 10.00 / 3 = 3.33
10 / 3 = 3.333333333333333

说明:

  • 第 7 行:导入 [kotlin.math] 包中的所有声明;
  • 第 11 行:两个整数相除是整数除法。每个操作都写在各自的模板中:与 Java 的拼接不同,无需担心相对于构造字符串的 + 运算符的运算符优先级;
  • 第 13 行:余数的符号与被除数相同;% 运算符也适用于实数;
  • 第 14 行:[rem] 是 % 运算符对应的函数;[mod] 返回与除数符号相同的余数,就像 Java 中的 [Math.floorMod] 。[(-5)] 中的括号是必要的:[-5.mod(2)] 会被解释为 [-(5.mod(2))],因为使用点运算符的函数调用优先于一元负号运算符;
  • 第 17 行:实数除以零不会导致错误;它返回无穷大([Infinity]),而对于 0/0 则返回特殊值 [NaN] (“Not a Number”)。在 [1 / zero] 中,整数 1 被实数除:该操作是实数运算。Kotlin 不在数值类型之间执行隐式转换,但算术运算符接受不同类型的操作数:[Int] 类有一个函数 [div(other: Double): Double];
  • 第 19–23 行:然而,把 整数 除以零会抛出 [ArithmeticException] 异常。除数是通过转换字符串 "0" 得到的,这样编译器就不知道它的值;
  • 第 27–28 行:上面的示例。[sqrt] 期望并返回 [Double]:2.0。由于 Kotlin 不会把 [Int] 隐式转换为 a [Double],所以 [sqrt(4)] 会被拒绝;我们写 [sqrt(4.0)];
  • 第 30 行:[pow] 函数在要求幂的数上调用;
  • 第 31 行:[absoluteValue] 是一个 扩展属性,使用时不带括号;
  • 第 34 行:[floor] 向下取整,[ceil] 向上取整,而 [truncate] 向零取整。要通过截断实数得到整数,请使用 [toInt()] 转换它,我们稍后会看到;
  • 第 36 行:[roundToInt] 四舍五入到最接近的整数;恰好位于两个整数正中间的值向上舍入:2.5 变为 3,-2.5 变为 -2。结果是 [Int]。Java 的 [Math.round] 就是这样工作的;
  • 第 38 行:请注意,Kotlin 的 [round] 函数的行为与 Java 的 [Math.round] 不同:它把恰好居中的值舍入到最接近的 偶数 整数(“银行家”舍入):2.5 变为 2,3.5 变为 4。结果是 [Double]。这是 Java 的 [Math.rint] 的行为;
  • 第 39 行:[coerceIn] 把 150 映射到区间 [0, 100],就像 [Math.clamp] (Java 21)一样。[coerceAtLeast] 和 [coerceAtMost] 函数只设置一个边界;
  • 第 42 行:Java 类 [Math] 的方法;
  • 第 45 行:运算符优先级,见下文;
  • 第 46 行:"x" + 1 + 2 从左到右求值:"x" + 1 得到字符串 "x1",然后再拼接 2。要先做加法,必须写成 "x" + (1 + 2);使用模板时,则写 ["x${1 + 2\}"];
  • 第 49 行:0.1 和 0.2 没有精确的二进制表示:它们的和并不恰好等于 0.3;
  • 第 51–52 行:由字符串创建的两个 [BigDecimal] 值。不要写 [BigDecimal(0.1)]:参数将是 [Double] 0.1,其精确值是 0.1000000000000000055511151231257827021181583404541015625。然而,使用字符串 "0.1" 的 [0.1.toBigDecimal()] 函数是可行的;
  • 第 53 行:精确的加法,使用 + 运算符书写;
  • 第 54–56 行:[3.toBigDecimal()] 转换一个整数。乘积的小数位数等于两个因数小数位数之和:59.97 × 1.2 = 71.964;
  • 第 58 行:[setScale(2, RoundingMode.HALF_UP)] 四舍五入到两位小数,恰好位于两个数字正中间的值向远离零的方向舍入:这是商业舍入;
  • 第 61 行:一个陷阱。Kotlin 的 / 运算符调用 [divide(divisor, RoundingMode.HALF_EVEN)] 方法:商保留被除数的小数位数,并舍入到最接近的值。由于 10 没有小数位,所以 10/3 等于 3;10.00/3 等于 3.33;
  • 第 63 行:Java 方法 [divide],其精度由 [MathContext.DECIMAL64] (16 位有效数字)指定。如果不指定精度或舍入模式,[divide] 方法就会引发 [ArithmeticException]:[Non-terminating decimal expansion; no exact representable decimal result.],因为 10/3 没有有限的十进制表示。因此,对于 [BigDecimal] 的除法,我们明确选择精度或小数位数以及舍入模式:[a.divide(b, 2, RoundingMode.HALF_UP)]。

3.4.5.3. 算术表达式求值中的运算符

计算算术表达式时,运算符的优先级顺序如下(从高到低):

[function calls, a.f()], [unary -], [*, /, %], [+, -]

同一个方块 [ ] 中的运算符具有相同的优先级。优先级相同时,从左到右求值:10 - 4 - 3 的值为 (10 - 4) - 3 = 3。可以使用括号指定不同的求值顺序。

3.4.5.4. 关系表达式

运算符如下:<、<=、、!=、>、>=;Kotlin 增加了 === 和 !(见下文)。它们的优先级:

  • >、>=、<、<=;
  • , !=, =, !==.

关系表达式的结果是布尔值:如果表达式为假,则为 [false] ,否则为 [true] 。

    val x = 5
    val end = x > 4

两个字符的比较

设 C1 和 C2 是两个字符。可以使用运算符 <、<=、==、!=、>、>= 来比较它们。比较的是它们的 Unicode 码——也就是数字。按照 Unicode 顺序,以下关系成立:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

字符 [c] 的 Unicode 码由它的 [c.code] 属性给出,其类型为 [Int]。在 Kotlin 中,[Char] 不是数字:你不能写 ['a' + 'b'] ,也不能把字符赋给整数变量,而 Java 允许这样做。

两个字符串的比较

它们逐个字符进行比较。两个字符之间遇到的第一个不相等,会使字符串得到符号相同的不等关系。考虑比较字符串 "Cart" 和 "Cat":

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

最后这个不等式使我们能够得出 "Cart" < "Cat" 的结论。考虑比较字符串 "Cat" 和 "Catkin"。它们在字符串 "Cat" 用尽之前是相等的。在这种情况下,用尽的字符串被判定为“较小”。因此我们有 "Cat" < "Catkin" 这一关系。

结构相等与引用相等

在这方面,Kotlin 纠正了 Java 中的一个经典陷阱。在 Java 中,当应用于两个字符串——或任意两个对象——时,运算符 == 和 != 比较的是 引用:如果两个变量指向内存中的同一个对象,[s1 == s2] 为真,而不是当两个字符串包含相同字符时才为真;要比较内容,必须写 [s1.equals(s2)]。在 Kotlin 中:

  • == 运算符比较 内容:[a == b] 被编译器翻译为对 [a.equals(b)] 方法的调用,并且之前会先测试 [null]:如果 [a] 等于 [null],则 [a == b] 等于 [b === null],不会有 [NullPointerException] 的风险。这就是 结构相等;!= 是它的否定;
  • === 运算符比较 引用:如果 [a === b] 中的 [a] 和 [b] 引用同一个对象,则为真。这就是 引用相等;!== 是它的否定。我们很少需要它。

对于基本类型([Int]、[Double]……),== 只是比较值。C# 对字符串的行为与 Kotlin 相同:它的 == 运算符比较字符串的内容。

两个字符串的顺序

运算符 < <= > >= 适用于字符串,就像适用于任何可比较的对象一样:在 Kotlin 中,[a < b] 是书写 [a.compareTo(b) < 0] 的另一种方式。[compareTo] 方法返回一个整数:

  • 如果两个字符串相等,则为零;
  • 如果字符串 1 大于字符串 2,则为正数;
  • 如果字符串 1 小于字符串 2,则为负数。

Kotlin 的 [equals] 和 [compareTo] 函数接受 [ignoreCase] 参数以忽略大小写:[s1.equals(s2, ignoreCase = true)](对应 Java 函数 [equalsIgnoreCase] 和 [compareToIgnoreCase])。语法 [ignoreCase = true] 是 具名参数的语法,我们在函数中还会遇到它。

[compareTo] 逐个字符地比较 Unicode 码:其结果是第一对不同字符的码之差,或者在其中一个字符串是另一个字符串的开头时,是长度之差。这不是字典序:由于 'é' 的码(233)大于 'f' 的码(102),"élan" 排在 "face" 之后。要对面向用户的文本排序,应使用 [Collator] 对象(来自 JDK 的 [java.text] 包),它应用特定语言的排序规则。[compareTo] 仍然是比较标识符、关键字和文件名的正确方法。

程序 [Basics12.kt] 如下:

// 关系表达式和字符串比较
package basics12

import java.math.BigDecimal
import java.text.Collator
import java.util.Locale

fun main() {
    val x = 5
    val end = x > 4
    println("x > 4 : $end, x == 5 : ${x == 5}, x != 5 : ${x != 5}")

    // 字符比较:比较它们的 Unicode 码
    println("'a' < 'b' : ${'a' < 'b'}, 'Z' < 'a' : ${'Z' < 'a'}, '9' < 'A' : ${'9' < 'A'}")
    println("codes : 'A'=${'A'.code}, 'a'=${'a'.code}, 'é'=${'é'.code}")

    // 字符串比较:== 比较内容,compareTo 和 < > 比较顺序
    val string1 = "cat"
    val string2 = "dog"
    val n = string1.compareTo(string2)
    val equal = string1 == string2
    println("n=$n, equal=$equal, string1 < string2 : ${string1 < string2}")
    println("\"Cat\".compareTo(\"Catkin\") : ${"Cat".compareTo("Catkin")}")

    // == 比较内容,=== 比较引用
    val string3 = "CAT".lowercase()
    println("string3=$string3, string1 == string3 : ${string1 == string3}")
    println("string1 === string3 : ${string1 === string3}, string1 === \"cat\" : ${string1 === "cat"}")
    // == 接受 null 值
    val absent: String? = System.getProperty("unknown.property")
    println("absent == string1 : ${absent == string1}, absent == null : ${absent == null}")

    // compareTo 逐个字符比较 Unicode 码
    println("\"élan\".compareTo(\"face\") : ${"élan".compareTo("face")}")
    println("\"Cat\".compareTo(\"cat\") : ${"Cat".compareTo("cat")}")
    // 忽略大小写(大写 / 小写)
    println("compareTo with ignoreCase = true : ${"Cat".compareTo("cat", ignoreCase = true)}")
    println("\"Cat\" == \"cat\" : ${"Cat" == "cat"}")
    println("\"Cat\".equals(\"cat\", ignoreCase = true) : ${"Cat".equals("cat", ignoreCase = true)}")
    // Collator 按某种语言的排序规则进行比较
    val collator = Collator.getInstance(Locale.FRENCH)
    println("collator.compare(\"élan\", \"face\") : ${collator.compare("élan", "face")}")
    println("collator.compare(\"Cat\", \"cat\") : ${collator.compare("Cat", "cat")}")

    // == 调用 equals:对于 BigDecimal,2.0 和 2.00 不相等
    val m1 = BigDecimal("2.0")
    val m2 = BigDecimal("2.00")
    println("m1 == m2 : ${m1 == m2}, m1.compareTo(m2) : ${m1.compareTo(m2)}, m1 >= m2 : ${m1 >= m2}")
}

结果:

> gradlew -q run -Pmain=basics12.Basics12Kt
x > 4 : true, x == 5 : true, x != 5 : false
'a' < 'b' : true, 'Z' < 'a' : true, '9' < 'A' : true
codes : 'A'=65, 'a'=97, 'é'=233
n=-1, equal=false, string1 < string2 : true
"Cat".compareTo("Catkin") : -3
string3=cat, string1 == string3 : true
string1 === string3 : false, string1 === "cat" : true
absent == string1 : false, absent == null : true
"élan".compareTo("face") : 131
"Cat".compareTo("cat") : -32
compareTo with ignoreCase = true : 0
"Cat" == "cat" : false
"Cat".equals("cat", ignoreCase = true) : true
collator.compare("élan", "face") : -1
collator.compare("Cat", "cat") : 1
m1 == m2 : false, m1.compareTo(m2) : 0, m1 >= m2 : true

说明:

  • 第 10 行:关系表达式;[end] 的类型是 [Boolean];
  • 第 14 行:字符比较;
  • 第 15 行:字符的 [code] 属性返回其 Unicode 码(在 Java 中写作 [(int) 'A']);
  • 第 20 行:变量 [n] 被赋予一个负整数,因为 "cat" < "dog":即 'c'(99)与 'd'(100)的码之差;
  • 第 21 行:如果两个字符串内容相同,变量 [equal] 的值为 [true] ,否则为 [false] ;
  • 第 22 行:< 运算符应用于两个字符串;
  • 第 23 行:先用尽的字符串是较短的那个;结果是长度之差:3 - 6。在字符串字面量中,\" 表示引号;
  • 第 26 行:[lowercase()] 函数在运行时构造一个包含 "cat" 的新字符串对象;
  • 第 27–28 行:[string1] 和 [string3] 内容相同,但引用两个不同的对象:== 返回 [true],=== 返回 [false]。然而,[string1 === "cat"] 为真:两个相同的字符串 字面量 在内存中只存储一次;
  • 第 30 行:Java 方法 [System.getProperty] 返回 JVM 属性的值,如果它不存在则返回 [null] ;其结果存储在 [String?] 类型的变量中;
  • 第 31 行:== 运算符接受左侧为 [null] 值:它返回 [false],而 Java 中调用 [absent.equals(string1)] 则会引发 [NullPointerException];
  • 第 34 行:233 - 102 = 131:对于 [compareTo],"élan" 排在 "face" 之后;
  • 第 35 行:'C'(67)- 'c'(99)= -32;
  • 第 37–39 行:忽略大小写时,“Cat”和“cat”相等;
  • 第 41–43 行:用于法语的 [Collator] :“élan”排在“face”之前,“Cat”排在“cat”之后(当字母相同时,小写字母排在大写字母之前)。[compare] 方法返回负整数、零或正整数,就像 [compareTo] 一样;
  • 第 46–48 行:由于 == 调用 [equals],它继承了该方法的特性。[BigDecimal] 类的行为会考虑小数位数:2.0 和 2.00 对 [equals] 来说不同,但对 [compareTo] 来说相等,因此对运算符 <<、<=、>> 和 >= 也是如此。因此,要比较两个 [BigDecimal] 金额,应使用 [compareTo(...) == 0],而不是 ==。

3.4.5.5. 布尔表达式

可以使用的运算符有与(&&)、或(||)和非(!)。布尔表达式的结果是布尔值。运算符优先级:

  • ! ;
  • && ;
  • ||.
    val x = 3.5
    val valid = x > 2 && x < 4

关系运算符的优先级高于 && 和 || 运算符。这两个运算符只在必要时才计算右侧操作数:在 [a && b] 中,如果 a 为假,则不计算 b;在 [a || b] 中,如果 a 为真,则不计算 b。这被称为“短路求值”。因此你可以放心地写 [text != null && text.length > 0]:在右侧,编译器知道 [text] 不等于 [null] (智能类型转换)。函数 [and] 和 [or],当应用于两个布尔值([a and b]、[a or b])时,执行相同的计算,但总是计算两个操作数;函数 [xor] 是异或。判断某个值是否落在区间内的测试,用运算符 [in] 写起来更简单:如果 2 ≤ x ≤ 4,则 [x in 2.0..4.0] 为真。

3.4.5.6. 按位运算

Kotlin 没有用于按位运算的符号运算符:Java 的 << >> >>> & | ^ ~ 被 中缀函数取代——即写在两个操作数之间的单参数函数,不带点号或括号:[i shl 4] 是书写 [i.shl(4)] 的另一种方式。设 [i] 和 [j] 是两个整数([Int] 或 [Long]):

操作
在 Java 中
作用
i shl n
i << n
把 i 向左移动 n 位。移入的位为零
i shr n
i >> n
把 i 向右移动 n 位。符号位被保留
i ushr n
i >>> n
无符号右移:移入的位为零,即使 i 为负数
i and j
i & j
对 i 和 j 逐位执行逻辑与
i or j
i|j
对 i 和 j 逐位执行逻辑或
i xor j
i ^ j
对 i 和 j 逐位执行异或运算
i.inv()
~i
对 i 求反码

移位只对 [Int] 和 [Long] 类型定义(也对无符号类型 [UInt] 和 [ULong] 定义,对它们来说 [shr] 移位总是用零填充):对于 [Short] 或 [Byte],值会先被转换为 [Int]。因此,编译器会拒绝 [s shl 1] (如果 [s] 是 [Short]):[unresolved reference 'shl' on receiver of type 'Short']。这些操作主要用于处理二进制数据;显式的名称的优点是不会与布尔运算符 && 和 || 混淆。

程序 [Basics13.kt] 如下:

// 位操作
package basics13

fun main() {
    val i = 100
    val j = -13
    // %08x:整数以 8 位(32 位)十六进制表示
    println("i=0x%08x, j=0x%08x".format(i, j))
    println("i shl 4=0x%08x, i shr 4=0x%08x".format(i shl 4, i shr 4))
    println("i and j=0x%08x, i or j=0x%08x".format(i and j, i or j))
    println("i xor j=0x%08x, i.inv()=0x%08x".format(i xor j, i.inv()))
    println("j shl 2=0x%08x, j shr 2=0x%08x".format(j shl 2, j shr 2))
    // 相同的值以二进制表示(低 16 位)
    println("i=${binary(i, 16)}, j=${binary(j, 16)}, i and j=${binary(i and j, 16)}")
    // 无符号右移 ushr:移入的位为零
    val m = -16
    println("m=${binary(m, 32)}")
    println("m shr 2=${binary(m shr 2, 32)}")
    println("m ushr 2=${binary(m ushr 2, 32)}")
    // 无符号整数:shr 移入零
    val k = 0xF123_0000U
    println("k=${k.toString(16)}, k shr 4=${(k shr 4).toString(16)}, k=$k")
}

// value 的低 n 位,以由 0 和 1 组成的字符串表示
fun binary(value: Int, n: Int): String = buildString {
    for (rank in n - 1 downTo 0) {
        append((value ushr rank) and 1)
    }
}

结果:

> gradlew -q run -Pmain=basics13.Basics13Kt
i=0x00000064, j=0xfffffff3
i shl 4=0x00000640, i shr 4=0x00000006
i and j=0x00000060, i or j=0xfffffff7
i xor j=0xffffff97, i.inv()=0xffffff9b
j shl 2=0xffffffcc, j shr 2=0xfffffffc
i=0000000001100100, j=1111111111110011, i and j=0000000001100000
m=11111111111111111111111111110000
m shr 2=11111111111111111111111111111100
m ushr 2=00111111111111111111111111111100
k=f1230000, k shr 4=f123000, k=4045602816

说明:

  • 第 5–6 行:两个 [Int] (32 位)类型的整数;
  • 第 8 行:%08x 说明符显示一个 8 位十六进制(x)整数,并用零补齐(08),表示它的 32 位:-13 变为 fffffff3;
  • 第 9 行:把 100(0x64)向左移动 4 位等价于乘以 2⁴(0x640);向右移动则等价于除以 2⁴(0x6);
  • 第 10–11 行:与、或、异或(按位异或)和反码。请注意,[inv] 函数像普通方法一样调用,带有句点和括号;
  • 第 12 行:负数的移位。[shr] 保留符号位:-13 向右移动 2 位得到 -4(0xfffffffc);
  • 第 14 行:[binary] 函数(第 26–28 行)显示整数的 n 个最低有效位。逐位检查 i 和 j 的逻辑与;
  • 第 16–19 行:[shr] 移位保留 m 的符号位,m 是负数;[ushr] 移位用零填充;
  • 第 21–22 行:无符号整数 [UInt],其最高有效位为 1:它等于 4,045,602,816,而具有相同位的 [Int] 值将是负数。它的 [shr] 移位 插入零。[toString(16)] 函数以十六进制写出它;
  • 第 26 行:[buildString] 函数通过连续添加来构造字符串:在随后的代码块中,[append] 函数把一个元素添加到当前正在构造的字符串中。它将在第 5 章介绍。[for (rank in n - 1 downTo 0)] 循环让 [rank] 从 n-1 降序遍历到 0;循环将在后面介绍;
  • 第 28 行:[(value ushr rank) and 1] 把第 [rank] 位设为 0,然后把它与其他位分开。

3.4.5.7. 运算符的组合

[a = a + b] 可以写成 [a += b];[a = a - b] 可以写成 [a -= b]。*、/ 和 % 运算符也是如此。因此,[a = a / 2] 可以写成 [a /= 2]。由于按位运算是函数,它们没有组合运算符:我们写 [a = a shl 2]。与简单赋值一样,复合赋值是语句,而不是表达式。它们不执行任何隐式转换:如果 [s] 是 [Short],[s += 1] 会被拒绝,[s = s + 1] 也一样,因为加法的结果是 [Int];我们写 [s = (s + 1).toShort()]。实际上,[Short] 和 [Byte] 很少用于计算。

3.4.5.8. 自增和自减运算符

记法 [variable++] 表示 [variable = variable + 1] 或 [variable += 1]。记法 [variable--] 表示 [variable = variable - 1] 或 [variable -= 1]。它们应用于 [var] 变量。在表达式中使用时,这些运算符有两种形式:

  • [i++] (后缀):表达式的值是自增 之前 i 的值;
  • [++i] (前缀):表达式的值是自增 之后 i 的值。

Kotlin 保留了它们,尽管赋值不是表达式;不过,应避免在较大的表达式中使用它们,因为这会损害可读性。

3.4.5.9. 没有三元运算符:if 表达式

Java 与 C 和 C# 一样,有一个三元运算符:表达式 [cond ? expr1 : expr2] 的值为 [expr1] (当条件 [cond] 为真时),否则为 [expr2] 。Kotlin 没有三元运算符;编译器会拒绝 [val z = x > 4 ? x + 1 : x - 1] 并给出消息 [syntax error: Unexpected tokens (use ';' to separate expressions on the same line)]。它不需要三元运算符,因为它的 *[if] 语句同时也是有值的 表达式* :

val i = if (j > 4) j + 1 else j - 1

表达式 [if (cond) expr1 else expr2] 按如下方式求值:

  • 计算表达式 [cond] 。它是一个布尔表达式;
  • 如果它为真,表达式的值就是 [expr1] 的值,并且不计算 [expr2] ;
  • 如果它为假,情况相反:表达式的值是 [expr2] 的值,并且不计算 [expr1] 。

如果 j > 4,上面的操作会把值 j+1 赋给变量 [i] ,否则赋 j-1。这与写 [if (j > 4) i = j + 1 else i = j - 1] 相同,但更简洁,而且 [i] 可以用 [val] 一起声明。作为表达式使用时,[if] 必须有 [else] 分支,这样表达式在所有情况下都有值。我们将在“简单选择结构”一节中介绍 [if] ,并在“分支结构”一节中介绍同样是表达式的 [when]。

3.4.5.10. 空运算符

与 Java 不同,Kotlin 有专门针对 [null] 值的运算符。我们在“空安全”一节中已经遇到过它们;下面是一个总结。设 [a] 是一个可空表达式:

运算符
作用
[a?.member]
安全调用:求值为 [a.member] (如果 a 不是 [null]),否则求值为 [null] (此时不计算成员:不调用函数)。安全调用可以链式使用:[a?.b?.c] 求值为 [null] ,只要链中任何一环求值为 [null]
[a ?: b]
Elvis 运算符:如果 a 不等于 [null],则求值为 a,否则为 b(此时仅当 a 等于 [null] 时才计算 b)。它用于提供后备值
[a!!]
断言:如果 a 不等于 [null],则求值为 a;否则抛出 [NullPointerException]
[a?.let { ... \}]
执行代码块,其中 a 的值被称为 [it],仅当 a 不等于 [null]

它们相当于 C# 中的 ?. 和 ?? 运算符。没有这些运算符的 Java 则改用三元运算符([a != null ? a : b])、[Objects.requireNonNullElse(a, b)] 方法,或 [Optional] 类及其 [map] 方法。Elvis 运算符的右侧也可以是中断正常执行的语句:[val n = input ?: return] 会在 [input] 的值为 [null] 时退出函数,而 [val n = input ?: throw IllegalArgumentException("missing input")] 会抛出异常;我们将在讨论异常时回到这种形式。

程序 [Basics14.kt] 综合运用了这些不同的运算符:

// 其他运算符
package basics14

// 返回与某个键关联的值,如果键未知则返回 null
fun valueOf(key: String): String? = if (key == "title") "Kotlin by example" else null

fun main() {
    // 布尔表达式
    val x = 3.5
    val valid = x > 2 && x < 4
    println("valid=$valid, !valid=${!valid}, valid || x > 10 : ${valid || x > 10}")
    println("x in 2.0..4.0 : ${x in 2.0..4.0}, valid xor true : ${valid xor true}")

    // 复合运算符
    var a = 10
    a += 5
    print("a += 5 : $a")
    a *= 2
    print(", a *= 2 : $a")
    a /= 4
    print(", a /= 4 : $a")
    a %= 4
    print(", a %= 4 : $a")
    // 位操作没有复合运算符
    a = a shl 2
    println(", a = a shl 2 : $a")

    // 自增和自减
    var i = 5
    val j = i++    // j 接收 i 的旧值,然后 i 自增
    val k = ++i    // i 先自增,然后 k 接收 i 的新值
    println("i=$i, j=$j, k=$k")
    i--
    println("i=$i")

    // 没有三元运算符:if 是表达式
    val n = 5
    val p = if (n > 4) n + 1 else n - 1
    val parity = if (n % 2 == 0) "even" else "odd"
    println("p=$p, $n is $parity")

    // 引用为 null 时的替代值:Elvis 运算符 ?:
    val input = valueOf("name")
    val name = input ?: "unknown"
    val age: Int? = "twenty".toIntOrNull()
    val displayedAge = age ?: -1
    println("name=$name, displayedAge=$displayedAge")
    // 仅当变量为 null 时才赋值
    var title = valueOf("subtitle")
    if (title == null) {
        title = "Untitled"
    }
    println("title=$title")
    // 仅当对象不为 null 时才访问成员:安全调用 ?.
    var text = valueOf("text")
    println("length=${text?.length}")
    text = valueOf("title")
    println("length=${text?.length ?: -1}")
    // 链式安全调用
    println("first word: ${valueOf("title")?.split(" ")?.first()?.uppercase()}")
    println("first word: ${valueOf("author")?.split(" ")?.first()?.uppercase() ?: "none"}")
    // !! 断言:如果值为 null 则抛出 NullPointerException
    println("title!!.length=${valueOf("title")!!.length}")
}

结果:

> gradlew -q run -Pmain=basics14.Basics14Kt
valid=true, !valid=false, valid || x > 10 : true
x in 2.0..4.0 : true, valid xor true : false
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a = a shl 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=17
first word: KOTLIN
first word: none
title!!.length=17

说明:

  • 第 5 行:对 "title" 键返回字符串、对任何其他键返回 [null] 的函数。它为程序提供 [String?] 类型的值;
  • 第 10 行:布尔表达式;
  • 第 12 行:同样的范围测试,使用 [in] 运算符书写;[valid xor true] 是两个布尔值的异或;
  • 第 15–26 行:组合运算符:10 + 5 = 15,15 × 2 = 30,30 ÷ 4 = 7(整数除法),7 % 4 = 3,3 shl 2 = 12。变量 [a] 用 [var] 声明,因为它的值会改变;
  • 第 30 行:[j] 被赋值 5,然后 [i] 被设为 6;
  • 第 31 行:[i] 变为 7,然后 [k] 被赋值 7;
  • 第 38–39 行:两个 [if] 表达式,取代了 Java 的三元运算符;
  • 第 43–44 行:[input] 等于 [null]:[name] 被赋值为“unknown”。它的类型是 [String],而不是 [String?]:Elvis 运算符确保 [name] 永远不会是 [null];
  • 第 46 行:类型为 [age] 的 [Int?] 等于 [null]:类型为 [displayedAge] 的 [Int] 被赋值 -1。没有拆箱,也没有异常的风险;
  • 第 49–51 行:只有当 [title] 等于 [null] 时才会赋值。我们本来可以更简单地写成 [val title = valueOf("subtitle") ?: "Untitled"];
  • 第 56 行:[text] 等于 [null];[text?.length] 等于 [null],而没有读取 [length] 属性;模板显示 [null];
  • 第 58 行:[text] 是 "Kotlin by example":它的长度是 17。对于 [null] 值,Elvis 运算符会返回 -1;
  • 第 60 行:安全调用链。[split(" ")] 把字符串拆分为单词列表(第 5 章),[first()] 返回第一个单词,而 [uppercase()] 把它转换为大写;
  • 第 61 行:同样的调用序列应用于 [null] 值:不会进行任何调用,表达式求值为 [null],而 Elvis 运算符用 "none" 替换它;
  • 第 63 行:!! 断言。[valueOf("title")] 的类型是 [String?],但程序员知道对于“title”键,它不等于 [null] ;断言使得可以直接使用 [length]。对于 "author" 键,它会引发 [NullPointerException]。

3.4.5.11. 通用运算符优先级

下表按从高到低的顺序列出了 Kotlin 中的运算符优先级:

运算符
结合性
[x.y] [x?.y] [f(x)] [a[i]] [x++] [x--] [x!!] (后缀)
LR
[+x] [-x] [!x] [++x] [--x] (前缀)
RL
[as] [as?] (类型转换)
LR
[*] [/] [%]
LR
[+] [-]
LR
[..] [..<] (区间)
LR
中缀函数:[shl] [shr] [ushr] [and] [or] [xor] [downTo] [step] [until]……
LR
[?:] (Elvis)
LR
[in] [!in] [is] [!is]
LR
[<] [<=] [>] [>=]
LR
[==] [!=] [===] [!==]
LR
[&&]
LR
[||]
LR
[=] [+=] [-=] [*=] [/=] [%=] (语句)
 

“LR”表示当运算符优先级相同时,按从左到右的顺序结合:当表达式包含优先级相同的运算符时,最左边的运算符先求值。“RL”表示从右到左的结合顺序。需要注意的三个要点是:

  • 中缀函数的优先级低于算术运算符:[1 shl 2 + 3] 等于 [1 shl 5],即 32;
  • 它们的优先级高于比较运算符:[x and 1 == 0] 的求值结果为 [(x and 1) == 0],这确实是想要的效果(在 Java 中,[x & 1 == 0] 会被拒绝,因为 == 的优先级高于 &);
  • Elvis 运算符的优先级低于算术运算符:[a ?: 0 + 1] 的求值结果为 [a ?: (0 + 1)]。要给结果加 1,必须写成 [(a ?: 0) + 1],就像程序 [Basics06.kt] 所做的那样。

如有疑问,请毫不犹豫地使用括号:它们也使表达式更易读。

3.4.5.12. 类型转换

在表达式中,可以暂时改变值的编码。这称为改变数据类型,即“类型转换”。Java 通过两种方式做到这一点:

  • 拓宽转换——例如从 [int] 到 [long] 或 [double]——由编译器自动执行;
  • 收窄转换——可能导致信息丢失,例如从 [double] 到 [int]——由程序员使用 [(type) value] 记法指定。

Kotlin 更为严格:它不在数值类型之间执行任何隐式转换,甚至拓宽转换也不例外。任何转换都必须使用下列函数之一显式请求:[toByte()]、[toShort()]、[toInt()]、[toLong()]、[toFloat()]或 [toDouble()],每种数值类型都具有这些函数(无符号类型则有 [toUInt()]、[toULong()]……)。因此,编译器会拒绝:

1
2
3
4
5
val i = 3
val l: Long = i
error: initializer type mismatch: expected 'Long', actual 'Int'.
val f: Float = i / 4
error: initializer type mismatch: expected 'Float', actual 'Int'.

你必须写 [val l: Long = i.toLong()]。这种严格性防止转换在程序员不知情的情况下发生,特别是那些在没有警告的情况下丢失精度的转换(例如 Java 中把 [long] 转换为 [float] 或 [double] )。它有两种模式:

  • 字面量 可以赋给任何能容纳它的类型:[val l: Long = 1000] 和 [val b: Byte = 5] 都是可以接受的;
  • 算术运算符和比较运算符接受不同数值类型的操作数:[i + l],其中 [i] 是 [Int],[l] 是 [Long],结果是 [Long]; [i * 1.5] 是 [Double]。这不是隐式转换,而是在 [Int] 类中存在函数 [plus(other: Long): Long]、[times(other: Double): Double] 等。

可能丢失信息的转换,通过 [toXxx()] 函数,与 Java 类型转换具有相同的效果:[toInt()] 应用于浮点数时会截断小数部分(向零截断);应用于 [Long] 时,只保留最低的 32 位。Kotlin 的类型转换,即 [as] 运算符,专用于对象(第 4 章):[d as Int],其中 [d] 是 [Double],并不会把浮点数转换为整数:编译器会发出警告([this cast can never succeed. Use 'toInt' to perform numeric conversion.]),而运行时会抛出异常([ClassCastException]))。

字符不是数字:使用 [code] 属性可以从字符得到其 Unicode 码,使用构造函数 [Char(code)] 可以从码得到字符。不过,你可以给字符加上一个整数(['A' + 2] 等于 'C'),也可以对两个字符做减法(['C' - 'A'] 等于 2)。

整数计算中的溢出或整数之间转换时的溢出从不会被报告:结果只是不正确。Kotlin 编译器也不会报告这一点,即使只涉及常量([Int.MAX_VALUE + 1])。存在这种风险时,应使用更大的类型进行计算([Long],或 JDK 的 [BigInteger] 类),或者使用 [addExact]、[subtractExact]、[multiplyExact]、[toIntExact] 等方法,它们来自 Java 类 [Math],如果超出限制,会抛出 [ArithmeticException] 异常。Kotlin 库没有等价物。

程序 [Basics15.kt] 如下:

// 类型转换
package basics15

import kotlin.math.roundToInt

fun main() {
    val i = 3
    val j = 4
    val f1 = (i / j).toFloat()
    val f2 = i.toFloat() / j
    println("f1=$f1, f2=$f2")

    // 没有隐式转换,即使不丢失信息也一样
    val l: Long = i.toLong()
    val d: Double = l.toDouble()
    println("l=$l, d=$d")
    // 但运算符接受不同类型的操作数
    val sum = i + l
    val product = i * 1.5
    println("i + l = $sum (${sum::class.simpleName}), i * 1.5 = $product (${product::class.simpleName})")

    // 可能丢失信息的转换
    val real = 3.99
    val truncated = real.toInt()
    val rounded = real.roundToInt()
    println("3.99.toInt()=$truncated, (-3.99).toInt()=${(-3.99).toInt()}, 3.99.roundToInt()=$rounded")
    val big = 3_000_000_000L
    val overflowed = big.toInt()
    println("3000000000L.toInt()=$overflowed")
    // 过大的实数会被限制为最大的整数值
    println("1e10.toInt()=${1e10.toInt()}, Double.NaN.toInt()=${Double.NaN.toInt()}")

    // 字符和整数
    val c = Char(65)
    val code = 'é'.code
    println("Char(65)=$c, code of 'é'=$code, 'A' + 2=${'A' + 2}, 'C' - 'A'=${'C' - 'A'}")
    // 一个数字及其值
    println("'7'.digitToInt()=${'7'.digitToInt()}, '7'.code=${'7'.code}")

    // 溢出:静默发生
    val max = Int.MAX_VALUE
    val next = max + 1
    println("Int.MAX_VALUE + 1 = $next, as a Long: ${max.toLong() + 1}")
    // Java 的 Math 类的 ...Exact 方法通过异常报告溢出
    try {
        val checked = Math.addExact(max, 1)
        println("checked=$checked")
    } catch (e: ArithmeticException) {
        println("Math.addExact(max, 1) : ${e::class.simpleName} - ${e.message}")
    }
    try {
        val conversion = Math.toIntExact(big)
        println("conversion=$conversion")
    } catch (e: ArithmeticException) {
        println("Math.toIntExact(big) : ${e::class.simpleName} - ${e.message}")
    }
}

结果:

> gradlew -q run -Pmain=basics15.Basics15Kt
f1=0.0, f2=0.75
l=3, d=3.0
i + l = 6 (Long), i * 1.5 = 4.5 (Double)
3.99.toInt()=3, (-3.99).toInt()=-3, 3.99.roundToInt()=4
3000000000L.toInt()=-1294967296
1e10.toInt()=2147483647, Double.NaN.toInt()=0
Char(65)=A, code of 'é'=233, 'A' + 2=C, 'C' - 'A'=2
'7'.digitToInt()=7, '7'.code=55
Int.MAX_VALUE + 1 = -2147483648, as a Long: 2147483648
Math.addExact(max, 1) : ArithmeticException - integer overflow
Math.toIntExact(big) : ArithmeticException - integer overflow

说明:

  • 第 9 行:[f1] 的值将是 0.0。除法 3/4 是整数除法,因为两个操作数的类型都是 [Int];它的结果 0 随后由 [Float] 函数 [toFloat()] 转换为浮点型;
  • 第 10 行:[i.toFloat()] 是转换为 [i] 的值 [Float]。现在我们有了一个 [Float] 类型的实数与一个 [Int] 类型的整数之间的除法,其结果是 [Float]:执行的是两个实数的除法,[f2] 的值为 0.75。在 [i.toFloat()] 操作中,[i] 是按 4 字节实数精确编码的值,而 [i.toFloat()] 是按近似的 4 字节实数编码的同一个值。这种转码只在计算期间发生:变量 [i] 始终保持其类型 [Int];
  • 第 14–15 行:向上转换,必须显式请求;
  • 第 18–19 行:不同类型之间的运算。结果类型以 [::class.simpleName] 显示:[Long] 和 [Double];
  • 第 24 行:把实数转换为整数会向零截断小数部分:3.99 变为 3,-3.99 变为 -3;
  • 第 25 行:要四舍五入,我们使用 [roundToInt()] ,它来自第 4 行导入的 [kotlin.math] 包,并直接返回 [Int];
  • 第 27 行:30 亿超出了 [Int] 的范围:无论有没有 L 后缀,字面量的类型都是 [Long];
  • 第 28 行:30 亿放不进 [Int]:只保留最低的 32 位,结果不再有意义;
  • 第 31 行:对 [Int] 来说太大的浮点数会被缩减为 [Int.MAX_VALUE];值 [NaN] 变为 0;
  • 第 34–36 行:字符与 Unicode 码之间的转换,以及字符运算;
  • 第 38 行:[digitToInt()] 函数返回数字的值(7),不要与它的 Unicode 码(55)混淆;
  • 第 42 行:溢出没有被注意到:结果是最小的 [Int] 值。使用 [Long] 执行的同一计算会得到正确的结果;
  • 第 46 行:使用 [Math.addExact] 时,溢出会触发 [ArithmeticException] 异常;
  • 第 52 行:[Math.toIntExact] 把 [Long] 转换为 [Int] ,并且在值放不进 [Int] 时也会抛出异常。

3.5. 程序流程控制语句

3.5.1. 停止

函数 [exitProcess] (来自 [kotlin.system] 包)使你可以停止程序的执行:

fun exitProcess(status: Int): Nothing

[exitProcess] 终止当前进程,并把控制权交还给调用进程,通常是命令解释器。[status] 的值,称为 返回码,可以由命令解释器使用。按照惯例,0 表示程序成功运行,任何其他值都表示错误。在 Windows 上,返回码在命令提示符下可通过 [%ERRORLEVEL%] 变量获得,在 PowerShell 中可通过 [$LASTEXITCODE] 变量获得;在 Linux 和 macOS 上,则在 shell 的 [$?] 变量中。因此,[exitProcess(0)] 会以返回码 0 终止程序的执行。

[exitProcess] 调用 Java 方法 [System.exit],该方法也可以直接使用。不过,它比那个方法有一个优势:其返回类型是 [Nothing]。[Nothing] 是那些 永远不会 返回值的表达式的类型,因为它们不会正常结束(程序终止、抛出异常、无限循环)。因此,编译器知道紧跟在对 [exitProcess] 的调用之后的语句永远不会被执行,并在检查时考虑这一点,我们将会看到。

如果不调用 [exitProcess],程序在其 [main] 函数结束(可能通过 [return] 语句)时以返回码 0 终止。如果它被无人捕获的异常终止,它会显示该异常并以返回码 1 终止。与 Java 一样,[main] 函数不能返回整数:[exitProcess] 是指定返回码的唯一方式。

程序 [Basics16.kt] 把返回码作为参数接收:

// 以退出码停止程序
package basics16

import kotlin.system.exitProcess

fun main(args: Array<String>) {
    println("Start of the program")
    // 退出码作为参数传入(参见关于程序参数的一节)
    // 没有参数或参数不是数字时,得到 null
    val code = args.firstOrNull()?.toIntOrNull()
    if (code == null) {
        System.err.println("Syntax: java -jar basics16.jar exit_code")
        exitProcess(1)
    }
    // 此处,编译器知道 [code] 不为 null:exitProcess 永不返回
    println("Stopping with exit code $code")
    exitProcess(code)
    println("This line is never executed")
}

要查看返回码,程序必须是由 shell 启动的进程。使用 [gradlew -q run -Pmain=basics16.Basics16Kt --args="3"] 时,启动的进程是 Gradle:非零返回码会使 [run] 任务失败,Gradle 会显示它自己的错误消息,而我们收到的是 Gradle 的返回码。因此,我们像第 2 章那样使用 [kotlinc] 编译器构建可执行归档([kotlinc Basics16.kt -include-runtime -d basics16.jar]),并用 [java -jar] 运行它。

bash 终端中的结果:

> java -jar basics16.jar 3
Start of the program
Stopping with exit code 3
> echo $?
3
> java -jar basics16.jar
Start of the program
Syntax: java -jar basics16.jar exit_code
> echo $?
1
> java -jar basics16.jar three
Start of the program
Syntax: java -jar basics16.jar exit_code
> echo $?
1

说明:

  • 第 6 行:[main] 函数在数组 [args] 中接收命令行参数。程序的参数列在下面;
  • 第 10 行:[args.firstOrNull()] 返回第一个参数,如果没有参数则返回 [null] ;运算符 [?.] 仅在值不为 [toIntOrNull()] 时才调用 [null],而 [toIntOrNull()] 在字符串不是整数时返回 [null] 。因此,无论是没有参数还是参数不是数字,结果都是 [null],其类型为 [Int?],而不会抛出任何异常。对应的 Java 程序则需要捕获 [NumberFormatException] 异常,该异常由 [Integer.parseInt] 抛出;
  • 第 13 行:程序以返回码 1 终止。错误消息写入错误输出 [System.err];
  • 第 16 行:编译器知道只有在 [code] 不为 [null] 时才会执行到这里,因为 [if] 块以对类型为 [Nothing] 的函数的调用结束。因此,从这一行起,声明为 [code] 的变量,其类型 [Int?] 被视为 [Int] :这称为“智能转换”。如果没有它,下一行中对 [exitProcess(code)] 的调用——它需要一个 [Int]——就会被拒绝。在 Java 中,编译器不知道 [System.exit] 永远不会返回控制权,因此必须在其后添加一条多余的 [return] 语句;
  • 第 17 行:以作为参数传入的返回码终止程序。下一行不会被执行。Kotlin 2.4 编译器接受它而不给出警告;IntelliJ IDEA 将其标记为“unreachable code”(无法访问的代码);
  • 结果:命令 [echo $?] 显示最近执行的程序的返回码:3,然后在两种错误情况下均为 1。

3.5.2. 简单判断结构

1
2
3
4
5
if (condition) {
    actions_condition_true
} else {
    actions_condition_false
}

说明:

  • 条件用圆括号括起来。它必须是 [Boolean] 类型:与 Java 一样,而与 C 语言不同,当 [if (n)] 中的 [n] 是整数时,Kotlin 会拒绝;
  • 动作不以分号结尾:在 Kotlin 中,行尾即语句结束。分号仅用于在同一行书写多条语句;
  • 只有在多于一条语句时才必须使用花括号;不过,即使只有一条语句也常常使用花括号,以提高可读性并避免在添加语句时出错。与 Java 一样,惯例是把左花括号放在行末;
  • [else] 子句可以省略;
  • 没有 [then] 关键字。

这种结构在算法上的等价形式是 if...then...else 结构:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

示例:

if (x > 0) { nx = nx + 1; sx = sx + x } else dx = dx - x

与 Java 的主要区别在于,Kotlin 的 [if] 也是一个表达式:它返回被执行分支的值。因此我们可以写 [val max = if (a > b) a else b]。这就是 Kotlin 没有三元运算符 [condition ? value1 : value2] 的原因:[if] 就是它的等价物。当 [if] 用作表达式时,必须带有 [else] 子句;否则,当条件为假时它将没有值。

选择结构可以嵌套。这有时会引出程序 [Basics17.kt] 所展示的问题:

// 简单选择结构 if
package basics17

fun main() {
    val n = 5
    // else 总是对应最近的 if
    if (n > 1)
        if (n > 6)
            println(">6")
        else
            println("<=6")

    // 使用花括号时,else 属于第一个 if
    val n2 = 0
    if (n2 > 1) {
        if (n2 > 6) {
            println(">6")
        }
    } else {
        println("<=1")
    }

    // 一系列选择:else if
    val grade = 13
    val honours: String
    if (grade < 10) {
        honours = "failed"
    } else if (grade < 12) {
        honours = "pass"
    } else if (grade < 14) {
        honours = "fairly good"
    } else {
        honours = "good"
    }
    println("grade=$grade, honours=$honours")

    // if 是表达式:它返回所执行分支的值
    val grade2 = 8
    val honours2 = if (grade2 < 10) "failed" else if (grade2 < 12) "pass" else "at least fairly good"
    println("grade=$grade2, honours=$honours2")
    // 相当于 Java 的三元运算符(n > 0 ? "positive" : "negative or zero")
    println("$n is ${if (n > 0) "positive" else "negative or zero"}")
    // 分支可以是一个块:其值是最后一个表达式的值
    val max = if (n > n2) {
        println("the largest is n")
        n
    } else {
        println("the largest is n2")
        n2
    }
    println("max=$max")
}

结果:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics17.Basics17Kt
<=6
<=1
grade=13, honours=fairly good
grade=8, honours=failed
5 is positive
the largest is n
max=5

说明:

  • 第 7–11 行:第 10 行的 [else] 属于哪个 [if] ?规则是 [else] 总是属于最近的 [if]:即第 8 行的 [if (n > 6)]。代码缩进对编译器没有影响,这里选择这样的缩进只是为了说明这一点;
  • 第 15–20 行:这里,我们想把 [else] 放在 [if (n2 > 1)], 旁边,而不是把 [else] 放在 [if (n2 > 6)]旁边。由于前面的规则,我们必须在 [if (n2 > 1) { ... }]周围加上花括号;
  • 第 26–33 行:一系列互斥的选择用连续的 [else if] 语句书写。条件按顺序测试;第一个计算结果为 true 的条件决定要执行的动作。变量 [honours] 在第 25 行被声明为 [val] 而没有赋值:编译器会验证在第 35 行使用它之前,它在每个分支中都被赋值——且仅赋值一次。在下一节中,我们将看到书写这一系列选择的更简洁的方法;
  • 第 39 行:[if] 被用作表达式。它的值——被选中的字符串——被赋给 [honours2]。这避免了声明没有初始值的变量;
  • 第 42 行:[if] 取代了 Java 的三元运算符,这里位于字符串模板 [${...}] 之内;
  • 第 44–49 行:当分支是一个块时,其值为块中最后一个表达式的值:第一个分支为 [n] ,第二个分支为 [n2] 。前面的语句照常执行。

3.5.3. 分支结构

3.5.3.1. when 语句

Kotlin 没有 [switch] 语句。它用 [when] 语句取而代之,后者更简单、功能更强大。其语法如下:

1
2
3
4
5
6
when (expression) {
    v1 -> actions1
    v2, v3 -> actions2
    ...
    else -> actions_otherwise
}

说明:

  • 控制表达式用圆括号括起来。它可以是任意类型:整数、字符、字符串、枚举值,以及 [Long]、[Double]、[Boolean]或任何对象。值使用 [==] 运算符进行比较,即使用 [equals] 方法进行比较;
  • 每个子句将一个或多个以逗号分隔的值与一个动作关联起来。位于箭头 [->] 之后的动作是单条语句或用花括号括起来的块;
  • 值 vi 不一定是常量:它们可以是任意表达式,按子句的顺序求值;
  • 只执行第一个匹配值所在子句的动作:无需写 [break],也不会从一个子句贯穿到下一个子句。因此,Java 传统 [switch] 语法中的经典错误——忘记写 [break]——是不可能发生的。这就是 Java 14 引入的箭头语法的工作方式,也是 Kotlin 中唯一使用的形式;
  • 当 [when] 用作语句时,[else] 子句——相当于 Java 的 [default]——可以省略。

算法示例:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

3.5.3.2. when 表达式及其各种子句

很多时候,使用分支结构只是为了选择一个值。与 [if] 一样,[when] 也可以为此用作表达式:

1
2
3
4
5
6
result = when (expression) {
    v1 -> value1
    v2, v3 -> value2
    ...
    else -> value_otherwise
}

[when] 表达式必须是穷尽的:它必须为控制表达式的所有可能取值指定一个值,这通常需要一个 [else] 子句。没有它,编译器会拒绝该程序:

error: 'when' expression must be exhaustive. Add an 'else' branch.

只有当编译器能够自行验证所有值都已处理时,[else] 子句才是不必要的:例如 [Boolean] 类型的表达式([true] 和 [false])、枚举(其所有常量;见下文关于枚举的一节)或密封类(第 4 章)。当一个子句需要多条语句时,就写成一个块,其值为最后一个表达式的值。没有与 Java 的 [yield] 语句等价的东西。

子句中可以包含以下内容来代替值:

  • 成员测试 [in range]:[in 1..10 -> "small"] 在表达式介于 1 和 10 之间时被求值。我们用 [!in] 表示不属于;
  • 类型测试 [is Type]:如果被检查的对象是 [is String -> ...] 类型,则选中该子句 [String]。在动作中,该对象随后会被自动视为 [String] (智能类型转换):无需像 Java 的 [case String s] 那样引入新变量。[!is] 检查对象不是给定类型;
  • 守卫:自 Kotlin 2.2 起,子句可以附加一个由 [if] 引入的条件:[is Int if o > 0 -> ...] 仅对正整数求值。这等价于 Java 21 中的 [when] 守卫。

最后,[when] 可以不带参数使用。这时,每个子句都是任意布尔条件,并选择第一个为真的条件。这是书写一系列 [if ... else if] 子句的更易读的方式。

子句按顺序求值:选中第一个满足条件的子句。与 Java 的 [switch] 不同,Kotlin 的 [when] 既能处理基本类型([Int]、[Double]……),也能处理对象:无需借助 [Integer] 就能带守卫地对整数进行分类。

程序 [Basics18.kt] 如下:

// 分支结构:when,语句和表达式
package basics18

fun main() {
    val choice = 2
    var error = false
    when (choice) {
        0 -> return
        1 -> m1()
        2 -> m2()
        else -> error = true
    }
    println("error=$error")

    // 同一分支对应多个值,String 类型的表达式
    val day = "saturday"
    when (day) {
        "saturday", "sunday" -> println("$day : weekend")
        else -> println("$day : weekday")
    }

    // when 也是表达式:它返回一个值
    val dayType = when (day) {
        "saturday", "sunday" -> "weekend"
        "monday", "tuesday", "wednesday", "thursday", "friday" -> "weekday"
        else -> "unknown day"
    }
    println("$day : $dayType")
    // 块的值是其最后一个表达式的值
    val nbHours = when (day) {
        "saturday" -> 4
        "sunday" -> 0
        else -> {
            val hours = 7
            hours + 1
        }
    }
    println("$day : $nbHours opening hour(s)")

    // 带范围的 when
    println("-5 : ${classify(-5)}")
    println("0 : ${classify(0)}")
    println("7 : ${classify(7)}")
    println("42 : ${classify(42)}")
    println("1000 : ${classify(1000)}")
    // 不带参数的 when:一系列条件
    val grade = 13
    val honours = when {
        grade < 10 -> "failed"
        grade < 12 -> "pass"
        grade < 14 -> "fairly good"
        else -> "good"
    }
    println("grade=$grade, honours=$honours")
    // 按对象的类型匹配
    val objects = arrayOf<Any?>(12, -3, "kotlin", 2.5, null)
    for (o in objects) {
        println("$o : ${describe(o)}")
    }
}

// 上面使用的函数
fun m1() {
    println("M1")
}

fun m2() {
    println("M2")
}

fun classify(n: Int): String = when (n) {
    in Int.MIN_VALUE..<0 -> "negative"
    0 -> "zero"
    in 1..10 -> "small"
    in 11..99 -> "medium"
    else -> "large"
}

fun describe(o: Any?): String = when (o) {
    null -> "no object"
    is Int if o > 0 -> "positive integer"
    is Int -> "negative or zero integer"
    is String -> "string of ${o.length} characters"
    else -> "object of type ${o::class.simpleName}"
}

结果:

> gradlew -q run -Pmain=basics18.Basics18Kt
M2
error=false
saturday : weekend
saturday : weekend
saturday : 4 opening hour(s)
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
grade=13, honours=fairly good
12 : positive integer
-3 : negative or zero integer
kotlin : string of 6 characters
2.5 : object of type Double
null : no object

说明:

  • 第 7–11 行:上述算法的 Kotlin 实现。当 [when] 用作指令时,子句中可以包含赋值;
  • 第 8 行:[return] 终止函数 [main],从而终止程序;
  • 第 18 行:两个值对应相同的动作,用逗号分隔;
  • 第 23–26 行:对字符串的 [when] 表达式。[else] 子句使其成为穷尽的;
  • 第 30–35 行:动作为块的子句:块中最后一个表达式 [hours + 1] (第 35 行)的值就是 [when] 表达式的值;
  • 第 71–76 行:函数 [classify] 使用区间对整数进行分类。[Int.MIN_VALUE..<0] 是从最小的 [Int] 到 0(不含)的整数区间,即负整数;[1..10] 包含 1 到 10(含)的整数。常量 0 被包含在这些区间之中。[else] 子句处理其余的值,在这里是大于或等于 100 的整数。函数体是一个表达式,写在符号 [=] 之后:稍后我们将回头讨论这些带表达式体的函数;
  • 第 48–52 行:一个不带参数的 [when] ,它改写了程序 [else if] 中的 [Basics17.kt] 序列:第一个为真的条件将其值赋给该表达式;
  • 第 56 行:一个包含不同类型对象的数组。其元素的类型 [Any?] (任意对象,或 [null])被显式指定:如果不指定,编译器会根据这些值推断出一个复杂类型并拒绝该程序(“type argument for reified type parameter 'T' was inferred to the intersection of ['Comparable<*>?' & 'Serializable?']”);
  • 第 79–84 行:函数 [describe] 根据对象类型进行选择。在第 80 行,值 [null] 只是 [when] 的另一个值。在第 81 行,守卫 [if o > 0] 可以将 [o] 与 0 比较,因为在对 [is Int] 进行测试之后,[o] 被视为 [Int]。同样,在第 83 行,字符串的属性 [length] 可以无需转换而直接使用。没有守卫的子句 [is Int] (第 82 行)必须放在带守卫的子句之后,否则它会将后者遮蔽。在第 84 行,[o::class.simpleName] 给出对象所属类的简单名称:[Double];
  • 第 63–68 行:由第一个 [when] 调用的两个函数。

下表总结了这两种语言之间的对应关系:

Java
Kotlin
[switch (x) { case 1: ... break; default: ... }]
[when (x) { 1 -> ... ; else -> ... }]
[case "saturday", "sunday" -> ...]
["saturday", "sunday" -> ...]
[default -> ...]
[else -> ...]
[yield value;]
块中的最后一个表达式
[case Integer i when i > 0 -> ...]
[is Int if x > 0 -> ...]
[case null -> ...]
[null -> ...]
(无等价物)
[in 1..10 -> ...]
[if ... else if] 链
[when { condition -> ... }]

3.5.4. 循环结构

3.5.4.1. 已知重复次数

for 结构

Kotlin 没有 C 和 Java 中的“三参数”循环([for (i = id; i <= if; i = i + ip)])。它的 [for] 循环遍历区间、数组或集合的元素;它相当于 Java 的 for-each 循环。要遍历整数,就遍历一个区间:

1
2
3
for (i in id..if step ip) {
    actions
}

说明:

  • [id..if] 是从 [id] 到 [if] 的整数区间,包含两端。[step ip] 设置序列的步长;它是可选的,默认为 1;
  • [id..<if]也可以写作 [id until if],是从 [id] 到 [if], 不含右端点的区间。它便于遍历包含 [n] 个元素的数组的下标:[for (i in 0..<n)];
  • [if downTo id] 是从 [if] 到 [id] 的递减序列;
  • 循环变量 [i] 由 [for] 声明,不带 [val] 或 [var]:它只存在于循环内部,且不能在循环体内被修改;
  • 只有在多于一个动作时才需要花括号。

其算法等价形式是“for”结构:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

它可以转换为“while”结构:

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

区间并不是 [for] 循环特有的语法:它们是对象([IntRange]、[IntProgression]、[CharRange]……),可以赋给变量、传给函数、用 [in] 运算符求值([if (x in 1..10)],如同在 [when] 中),或使用标准库的函数来操作([(1..10).sum()])。字符区间也存在:['a'..'z']。

对数组或集合的 for 循环

语法如下:

1
2
3
for (variable in collection) {
    instructions
}

说明:

  • [collection] 是可迭代对象的数组或集合(实际上,是任何具有 [iterator()] 函数的对象)。我们将在第 5 章介绍集合([List]、[Set]、[Map]……);
  • *[variable]* 的类型是根据集合元素的类型推断出来的:不需要显式指定;
  • [variable] 是循环的局部变量,将依次取集合中的所有值。它是只读的,就像被声明为 [val] 一样:在循环内不能给它赋其他值;
  • 要遍历数组的下标,请使用其属性 [indices]:[for (i in array.indices)];要同时获得下标和元素,请使用函数 [withIndex()]:[for ((i, element) in array.withIndex())]。

repeat 函数

当你想把一段指令恰好执行 [n] 次时,标准库中的 [repeat] 函数是最简单的方式:

1
2
3
repeat(n) {
    instructions
}

在该块内,名称 [it] 表示当前迭代的序号,范围从 0 到 n-1。这个块实际上是一个 lambda——传给函数 [repeat] 的匿名函数:我们将在第 7 章介绍 lambda。

3.5.4.2. 重复次数未知

while 循环

1
2
3
while (condition) {
    actions
}

只要条件为真,循环就会继续。循环可能一次也不执行。说明与 [for] 相同。对应的算法结构是 while 结构:

1
2
3
while condition
    actions
endwhile

“Do While”循环

语法如下:

1
2
3
do {
    instructions
} while (condition)

循环持续到条件的计算结果为 false 为止。这里,循环至少执行一次。Kotlin 的一个独特之处:在循环体内声明的变量在 [while] 的条件中可见,这使你可以写出 [do { val line = readln() } while (line != "end")]。对应的算法结构是“repeat...until”结构:

1
2
3
repeat
    actions
until not condition

没有“通用”for 结构

Java 的 [for (start_instructions; condition; end_of_loop_instructions)] 循环在 Kotlin 中不存在。当区间不够用时,我们就写出等价的 [while] 循环:

1
2
3
4
5
start_instructions
while (condition) {
    instructions
    end_of_loop_instructions
}

3.5.4.3. 循环控制语句

语句
作用
[break]
退出 [for]、[while]、[do ... while] 循环
[continue]
进入 [for]、[while]、[do ... while] 循环的下一次迭代
[break@label]
退出以标签 [label@] 为前缀的循环,即使该语句位于嵌套循环之内
[continue@label]
进入以标签 [label@] 为前缀的循环的下一次迭代

标签是一个标识符后跟字符 [@],放在循环之前:[search@ for (...)]。在 [break] 或 [continue] 之后引用它,中间不留空格:[break@search]。在 Java 中,标签后面跟的是冒号([search:])。

3.5.4.4. 示例

程序 [Basics19.kt] 如下:

// 循环结构
package basics19

fun main() {
    // 计算前 10 个整数之和的四种方式
    val n = 10
    var sum = 0
    for (i in 1..n) {
        sum += i
    }
    println("for : sum=$sum")

    var i = 1
    sum = 0
    while (i <= n) {
        sum += i
        i++
    }
    println("while : sum=$sum")

    i = 1
    sum = 0
    do {
        sum += i++
    } while (i <= n)
    println("do while : sum=$sum")

    // 标准库可以计算范围内元素之和
    println("sum : sum=${(1..n).sum()}")

    // 范围和数列
    var product = 1
    for (k in 1..5) {
        product *= k
    }
    println("5! = $product")
    for (k in 0..<5) print("$k ")    // 不包含 5(也可写作 0 until 5)
    println()
    for (k in 10 downTo 0 step 2) print("$k ")
    println()
    for (c in 'a'..'e') print(c)
    println()
    // repeat:重复一个块 n 次;它是重复的序号(0、1、……)
    repeat(3) {
        print("[round $it] ")
    }
    println()

    // 遍历数组或集合的元素
    val friends = arrayOf("paul", "hélène", "jacques", "sylvie")
    for (name in friends) {
        println(name)
    }
    // 通过索引
    for (j in friends.indices) {
        print("${friends[j].length} ")
    }
    println()
    // 同时获取元素和索引
    for ((j, name) in friends.withIndex()) {
        println("friends[$j]=$name")
    }

    // break 和 continue
    for (k in 1..10) {
        // 跳过偶数
        if (k % 2 == 0) {
            continue
        }
        // 到 7 之后停止
        if (k > 7) {
            break
        }
        print("$k ")
    }
    println()

    // 用 break 退出的无限循环:大于 50 的第一个 7 的倍数
    var multiple = 50
    while (true) {
        multiple++
        if (multiple % 7 == 0) {
            break
        }
    }
    println("first multiple of 7 greater than 50: $multiple")

    // 带标签的 break:同时退出两层循环
    val grid = arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, -5, 6), intArrayOf(7, 8, 9))
    search@ for (row in grid.indices) {
        for (column in grid[row].indices) {
            if (grid[row][column] < 0) {
                println("first negative at [$row][$column]")
                break@search
            }
        }
    }
}

结果:

> gradlew -q run -Pmain=basics19.Basics19Kt
for : sum=55
while : sum=55
do while : sum=55
sum : sum=55
5! = 120
0 1 2 3 4
10 8 6 4 2 0
abcde
[round 0] [round 1] [round 2]
paul
hélène
jacques
sylvie
4 6 7 6
friends[0]=paul
friends[1]=hélène
friends[2]=jacques
friends[3]=sylvie
1 3 5 7
first multiple of 7 greater than 50: 56
first negative at [1][1]

说明:

  • 第 6–29 行:计算前 10 个整数之和的四种方法;
  • 第 8–11 行:[for] 循环遍历区间 [1..n],包括 10。循环变量 [i] 只存在于循环内部:第 13 行声明的变量 [i] 是另一个不同的变量;
  • 第 15–17 行:等价的 [while] 循环:显式写出 [i] 的初始化、条件检查和递增。这是通用 Java [for] 循环的 Kotlin 翻译;
  • 第 24 行:[i++] 返回 [i] 递增之前的值:先把 [i] 加到 [sum] 上,然后 [i] 再递增。运算符 [++] 和 [--] 在 Kotlin 和 Java 中都存在;
  • 第 29 行:区间 [1..n] 是一个对象;它的函数 [sum()] 返回其元素之和。这是在 Kotlin 中最惯用的写法。区间两边的圆括号是必需的:函数调用的优先级高于运算符 [..];
  • 第 33–36 行:计算 5! = 1 × 2 × 3 × 4 × 5;
  • 第 37 行:一个上界不包含在内的区间:[k] 的取值从 0 到 4。当循环体只有一条语句时,可以将它与 [for] 写在同一行;
  • 第 39 行:一个递减序列,从 10 到 0,步长为 2;
  • 第 41 行:一个字符区间;
  • 第 44–45 行:该块执行 3 次;[it] 依次被设为 0、1 和 2;
  • 第 51–52 行:[for] 循环遍历数组 [friends] 的元素;
  • 第 55–56 行:[friends.indices] 是数组下标的区间,在这里是 [0..3] 。显示每个名字的长度;
  • 第 60–61 行:[friends.withIndex()] 返回(下标,元素)元组。语法 [(j, name)] 将它们分解为两个变量:这是一种解构赋值,我们将在本章末尾再讨论它;
  • 第 65–74 行:对偶数,[continue] 跳到下一次迭代;一旦 [break] 超过 7,[k] 就停止循环;
  • 第 80–86 行:一个无限循环 [while (true)],通过 [break] 退出。当终止条件在循环中间才计算出来时,这种形式很方便。我们将把它用于键盘输入;
  • 第 89–94 行:在二维数组(整数数组的数组,[IntArray])中查找第一个负数。标签 [search@] (第 90 行)为外层循环命名;语句 [break@search] (第 94 行)一次性退出两层循环。简单的 [break] 只会退出内层循环。Kotlin 没有 [goto] 语句:在这种特定情况下,由标签来起这个作用。

3.6. 异常处理

Kotlin 和 Java 中的许多函数都可能抛出异常,即错误。当一个函数可能抛出异常时,程序员应当处理它,使程序具有更强的容错能力:应当始终避免应用程序突然终止。

3.6.1. try/catch/finally 结构

异常处理遵循如下模式:

1
2
3
4
5
6
try {
    code likely to throw an exception
} catch (e: Exception) {
    handle the exception e
}
next statement

如果 [try] 块中的代码没有抛出异常,则继续执行下一条语句;否则,执行转到 [catch] 块的主体,然后再执行下一条语句。请注意以下几点:

  • [e] 是 [Exception] 类型或其派生类型的对象。与 Kotlin 中的任何声明一样,名称在前,类型在后:[e: Exception]。异常有许多类型:[ArrayIndexOutOfBoundsException]、[NumberFormatException]、[ArithmeticException]、[IllegalArgumentException]、[IllegalStateException]、[NullPointerException]、[IOException]等。这些都是 Kotlin 直接使用的 Java 异常类(最常见的几个也以相同的名称出现在 [kotlin] 包中,无需 [import])。写成 [catch (e: Exception)],表示你想处理所有类型的异常。如果 [try] 子句中的代码可能产生多种类型的异常,你可能希望更具体地用多个 [catch] 子句来处理异常:
1
2
3
4
5
6
7
8
try {
    code likely to throw the exceptions
} catch (e1: ArrayIndexOutOfBoundsException) {
    handle the exception e1
} catch (e2: NumberFormatException) {
    handle the exception e2
}
next statement

[catch] 子句按顺序求值;执行第一个类型与异常匹配的子句。因此,处理特定异常类型的子句必须位于处理更一般类型的子句之前。注意:与 Java 编译器不同,Kotlin 编译器不会拒绝永远无法到达的子句;这需要程序员自己来保证(我们稍后会回到这个问题);

  • Kotlin 没有 Java 的多重 [catch] 子句([catch (IOException | NumberFormatException e)])。你可以写多个子句,或者写一个针对更一般类型的子句,并在其中测试异常类型,例如使用 [when];
  • 你可以添加一个 [finally] 子句,与 [try / catch] 子句配合使用:
1
2
3
4
5
6
7
8
try {
    code likely to throw an exception
} catch (e: Exception) {
    handle the exception e
} finally {
    code executed after try or catch
}
next statement

无论是否发生异常,[finally] 子句中的代码总是会被执行。通常,这里是关闭文件的地方;我们将看到,使用 [use] 函数有一种更简单的方式;

  • 在 [catch] 子句中,你可能不想使用异常对象。这时,可以把它命名为 _:[catch (_: NumberFormatException)],其中字符 _ 表示不会被使用的匿名变量;
  • 异常有一个名为 [message] 的属性(相当于 Java 中的 [getMessage()] 方法),其中包含描述所发生错误的消息。它的类型是 [String?]:有些异常没有消息。要显示它,可以这样写:
1
2
3
4
} catch (ex: Exception) {
    System.err.println("The following error occurred: ${ex.message}")
    ...
}
  • 异常的 [toString()] 方法返回其类的完整名称,后跟其消息;它的 [printStackTrace()] 方法还会显示调用栈——即出错时正在执行的函数列表——以及源文件名和行号。这对开发人员来说是最有用的信息,但并不是给用户看的。在本课程中,我们最常显示异常类的名称——[ex.javaClass.name] 或 [ex.javaClass.simpleName]——及其消息。[ex.javaClass] 是对象的 Java 类,即 Java 中由 [getClass()] 方法返回的那个类;
  • 最后,这是与 Java 的一个重要区别,[try] 是一个表达式:如果没有发生异常,其值为 [try] 块中最后一个表达式的值;如果发生了异常,则为 [catch] 块中最后一个表达式的值。[finally] 子句不影响这个值。因此,我们可以写成 [val n = try { text.toInt() } catch (_: NumberFormatException) { 0 }]。

3.6.2. 第一个示例

程序 [Basics20.kt] 演示了因使用不存在的数组元素而产生的异常:

// 由不正确的数组索引引起的异常
package basics20

fun main() {
    val tab = intArrayOf(0, 1, 2, 3)
    // 连同索引一起显示数组
    for (i in tab.indices) {
        println("tab[$i]=${tab[i]}")
    }
    // 显示数组的元素
    for (elmt in tab) {
        println(elmt)
    }
    // 生成异常
    try {
        tab[100] = 6
    } catch (e: Exception) {
        System.err.println("The following error occurred: ${e.javaClass.name} - ${e.message}")
        return
    } finally {
        println("finally ...")
    }
    println("This line is not executed")
}

结果:

> gradlew -q run -Pmain=basics20.Basics20Kt
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: java.lang.ArrayIndexOutOfBoundsException - Index 100 out of bounds for length 4
finally ...

说明:

  • 第 16 行:该语句抛出异常,因为数组 [tab] 在下标 100 处没有元素。编译器不检查下标,即使是常量下标:该错误只有在运行时才会被 Java 虚拟机检测到;
  • 第 17 行:[catch (e: Exception)] 子句捕获所有异常;
  • 第 18 行:异常的类型为 [java.lang.ArrayIndexOutOfBoundsException],其消息指出了错误的下标和数组的大小(结果的倒数第二行);
  • 第 19 行:退出函数 [main],从而退出程序;
  • 第 20–21 行:[finally] 子句被执行了(结果的最后一行),尽管 [catch] 子句中包含一条 [return] 语句。请注意,[finally] 子句总是会被执行;
  • 第 23 行:由于 [return],这一行不会被执行。

3.6.3. 受控输入

下面是另一个示例 [Basics21.kt],其中我们处理将不表示整数的字符串转换为整数时引发的异常:

// 输入年龄并处理转换异常
package basics21

fun main() {
    // 询问姓名
    print("Name: ")
    val name = readlnOrNull() ?: ""
    // 询问年龄
    var age = 0
    var ageOK = false
    while (!ageOK) {
        // 提问,读取并检查答案
        print("age: ")
        try {
            age = readln().toInt()
            ageOK = age >= 1
        } catch (_: NumberFormatException) {
            // ageOK 保持为 false
        }
        if (!ageOK) {
            println("Incorrect age, try again...")
        }
    }
    // 最终显示
    println("Your name is $name and you are $age year(s) old")

    // 相同的输入,将 try 用作表达式
    var age2: Int
    while (true) {
        print("age: ")
        // try 的值是 try 块的值,发生异常时则是 catch 块的值
        age2 = try {
            readln().toInt()
        } catch (_: NumberFormatException) {
            0
        }
        if (age2 >= 1) break
        println("Incorrect age, try again...")
    }
    println("Your name is $name and you are $age2 year(s) old")
}

结果(在键盘上输入的内容已插入到显示中):

1
2
3
4
5
6
> gradlew -q run -Pmain=basics21.Basics21Kt
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
age: 23
Your name is dupont and you are 23 year(s) old
> gradlew -q run -Pmain=basics21.Basics21Kt
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 99999999999
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old
age: abc
Incorrect age, try again...
age: 7
Your name is durand and you are 7 year(s) old

说明:

  • 第 7 行:如果输入流已关闭,[readlnOrNull] 会得到 [null]:[?:] 运算符将其替换为空字符串;
  • 第 11–21 行:年龄输入循环;
  • 第 15 行:在键盘上输入的行由函数 [toInt] 转换为整数。如果无法转换,该函数会抛出 [NumberFormatException] 异常。这就是为什么要把该操作放在 [try / catch] 之内。另一方面,如果输入流已关闭,函数 [readln] 会抛出异常:我们不捕获这个异常,因为捕获它会导致程序无法终止;
  • 第 16 行:如果执行到这一行,说明转换成功。不过,我们还要验证得到的整数确实大于或等于 1;
  • 第 17 行:如果抛出 [NumberFormatException] 异常,我们就转到 [catch], 其中什么也不做。因此,初始化为 [ageOK] 的布尔变量 [false] 仍保持为 [false]。未使用的异常变量,即匿名变量 _。只捕获预期的异常:[catch (_: Exception)] 子句还会掩盖未预料到的错误;
  • 第 20–21 行:如果年龄不正确,则显示错误消息;
  • 第 28–40 行:同样的输入,改用将 [try] 作为表达式来写。如果转换成功,[try] 的值就是得到的整数;否则,它的值是 [catch] 块的值 0,这个值会被第 37 行的测试拒绝。通过 [while (true)] 无限循环并经由 [break] 退出,就避免了使用布尔变量 [ageOK]。编译器知道只有在给 [age2] 赋值之后才会退出循环;因此,即使它是在没有初值的情况下声明的,编译器也允许在第 40 行使用它。

对 [Int] 来说过大的数——例如 99999999999——同样会触发 [NumberFormatException]:因此它与其他无效输入一样被处理(第二次执行)。

使用异常来验证输入在 Java 中是常见做法,但 Kotlin 提供了更好的解决方案:本章开头介绍的函数 [toIntOrNull()]返回 [null] 而不是抛出异常。这样我们就可以写 [val age = readln().toIntOrNull()] ,接着写 [if (age != null && age >= 1)],而不需要 [try]。这正是我们在后面的示例应用程序中要采用的做法。异常应当留给异常情况使用。

3.6.4. 多个 catch 子句与异常抛出

程序本身可以使用语句 [throw] 抛出异常:

throw IllegalArgumentException("error message")

Kotlin 中没有 [new] 运算符:只需调用对象的类构造函数即可创建对象。当前函数的执行停止,异常沿着调用它的函数向上传播,直到某个 [catch] 子句处理它;如果没有任何子句处理它,程序就会终止,并显示异常和调用栈。在 [catch] 子句中,[throw e] 语句会重新抛出当前异常,例如在记录日志之后。

在 Kotlin 中,[throw] 是类型为 [Nothing] 的表达式(与 [exitProcess] 一样)。因此它可以用在任何需要值的地方,例如在 [?:] 运算符之后:[val name = input ?: throw IllegalArgumentException("missing name")]。

与 Java 一样,Kotlin 不为 [catch] 子句提供过滤器:要仅在某些情况下处理异常,需要在子句中测试条件,必要时重新抛出异常。

对于最常见的检查,Kotlin 标准库提供了替我们抛出异常的函数:

函数
作用
[require(condition) { message }]
检查参数:如果条件为假,则抛出 [IllegalArgumentException] ,其消息由该块计算得出
[requireNotNull(value) { message }]
如果 [value] 等于 [null],则抛出 [IllegalArgumentException];否则,以非空类型返回该值。这等价于 Java 的 [Objects.requireNonNull],后者则抛出 [NullPointerException]
[check(condition) { message }]
检查一个条件:如果条件为假,则抛出 [IllegalStateException]
[checkNotNull(value) { message }]
如果 [value] 等于 [null],则抛出 [IllegalStateException],否则返回该值
[error(message)]
总是抛出 [IllegalStateException];它的类型是 [Nothing],用于表示不应出现的情况

消息由一个块(lambda)生成,仅当检查失败时才会执行:一切正常时不会白白计算字符串。

程序 [Basics22.kt] 演示了这些可能性:

// 多个 catch 子句,抛出异常
package basics22

fun main() {
    val inputs = arrayOf("12", "abc", "", "99999999999", "-3", "150")
    for (input in inputs) {
        try {
            val age = readAge(input)
            println("[$input] : age=$age")
        } catch (e: NumberFormatException) {
            // catch 子句上没有过滤器:我们在子句内部进行测试
            if (input.isEmpty()) {
                println("[$input] : empty input")
            } else {
                println("[$input] : ${e.javaClass.simpleName} - ${e.message}")
            }
        } catch (e: IllegalArgumentException) {
            println("[$input] : ${e.javaClass.simpleName} - ${e.message}")
        }
    }

    // require、requireNotNull、check、error:抛出异常的检查
    val names = arrayOf("dupont", null)
    for (name in names) {
        try {
            val valid = requireNotNull(name) { "the name is mandatory" }
            println("name=$valid")
        } catch (e: IllegalArgumentException) {
            println("${e.javaClass.simpleName} - ${e.message}")
        }
    }
    for (input in arrayOf("45", "200")) {
        try {
            println("age=${readAge2(input)}")
        } catch (e: IllegalArgumentException) {
            println("${e.javaClass.simpleName} - ${e.message}")
        }
    }
    for (state in arrayOf("open", "closed", "broken")) {
        try {
            println("$state : ${process(state)}")
        } catch (e: IllegalStateException) {
            println("$state : ${e.javaClass.simpleName} - ${e.message}")
        }
    }
}

// 抛出异常的函数
fun readAge(text: String): Int {
    // toInt 抛出 NumberFormatException
    val age = text.toInt()
    // 如果年龄超出范围,我们自己抛出异常
    if (age < 0 || age > 130) {
        throw IllegalArgumentException("age out of bounds [0,130] : $age")
    }
    return age
}

// 用 require 做同样的检查
fun readAge2(text: String): Int {
    val age = text.toInt()
    require(age in 0..130) { "age out of bounds [0,130] : $age" }
    return age
}

// check 验证状态,error 报告不可能出现的情况
fun process(state: String): String {
    check(state != "closed") { "operation impossible on a closed resource" }
    return when (state) {
        "open" -> "processing done"
        else -> error("unknown state: $state")
    }
}

结果:

> gradlew -q run -Pmain=basics22.Basics22Kt
[12] : age=12
[abc] : NumberFormatException - For input string: "abc"
[] : empty input
[99999999999] : NumberFormatException - For input string: "99999999999"
[-3] : IllegalArgumentException - age out of bounds [0,130] : -3
[150] : IllegalArgumentException - age out of bounds [0,130] : 150
name=dupont
IllegalArgumentException - the name is mandatory
age=45
IllegalArgumentException - age out of bounds [0,130] : 200
open : processing done
closed : IllegalStateException - operation impossible on a closed resource
broken : IllegalStateException - unknown state: broken

说明:

  • 第 5 行:模拟的输入,有效或无效;
  • 第 8 行:[readAge] 函数(第 49–56 行)可能触发多种类型的异常;
  • 第 10 行:输入 "abc"、"" 和 "99999999999" 会触发 [NumberFormatException];
  • 第 12–15 行:由于没有过滤器,空输入在 [catch] 子句内部被区分出来;
  • 第 17 行:由 [readAge] 本身抛出的异常;
  • 第 26 行:[requireNotNull] 抛出 [IllegalArgumentException] ,如果 [name] 等于 [null];其消息是由该块计算得出的消息(结果的第 9 行)。否则,它返回类型为 [name] 的 [String] 值:变量 [valid] 不可为空;
  • 第 54 行:如果年龄超出范围,函数 [readAge] 会抛出异常;
  • 第 62 行:同样的检查,改用 [require] 书写。条件使用运算符 [in] 和一个区间;
  • 第 68 行:[check] 检查对象是否处于允许该操作的状态;
  • 第 71 行:[error] 抛出 [IllegalStateException]。由于它的类型是 [Nothing],它可以作为 [when] 表达式某个分支的结尾,该表达式的类型为 [String]。

第 10 行和第 17 行中 [catch] 子句的顺序很重要:类 [NumberFormatException] 派生自类 [IllegalArgumentException] ([NumberFormatException] 是不正确参数的一种特殊情况)。如果我们把两个子句的顺序颠倒,[IllegalArgumentException] 子句也会拦截 [NumberFormatException] 的情况,而 [NumberFormatException] 子句就再也不会被执行。Java 编译器会拒绝这个已经变得无法到达的子句([error: exception NumberFormatException has already been caught]);而 Kotlin 2.4 编译器却不报任何错误或警告地接受它。这样,空输入将显示为 [[] : NumberFormatException - For input string: ""],错误也就不会被察觉。

3.6.5. Kotlin 中没有受检异常

这是 Java 与 Kotlin 之间最引人注目的区别之一。异常是对象,其类构成一个层次结构。它们是 Java 类:类 [kotlin.Throwable] 只是 [java.lang.Throwable] 的另一个名称,类 [Exception]、[RuntimeException]、[IllegalArgumentException]……也是如此:

Image

  • 根类是 [Throwable];
  • 类 [Error] 及其派生类表示严重的虚拟机问题([OutOfMemoryError]、[StackOverflowError]……),程序通常不会试图拦截它们;
  • 类 [RuntimeException] 及其派生类([NullPointerException]、[ArithmeticException]、[ArrayIndexOutOfBoundsException]、[IllegalArgumentException]、[NumberFormatException]、[IllegalStateException]……)通常表示编程错误或不正确的数据;
  • 其他派生自 [Exception] 的类([IOException]、[InterruptedException]、[ParseException]、[SQLException]……)报告由程序环境引起的事件(文件缺失、网络中断、数据库宕机),编写良好的程序必须预见到这些事件。

在 Java 中,后一类异常被称为“受检异常”:Java 编译器会验证,能够抛出这类异常的方法——无论是直接抛出还是通过调用另一个方法——要么使用 [catch] 子句捕获它,要么 在其签名中声明它,方法是使用 [throws] 关键字:

String readFile(String name) throws IOException { ... }

责任随后被传递给调用方法,如此类推。派生自 [RuntimeException] 和 [Error] 的异常被称为“非受检”异常:可以捕获它们,但编译器并不要求这样做。

Kotlin 没有受检异常。与 C# 一样,所有异常都是非受检的:编译器从不要求捕获或声明异常,关键字 [throws] 也不存在。由 Java 方法抛出的 [IOException] 在 Kotlin 看来只是另一个异常。语言设计者的这一选择是基于 Java 的经验:

  • 在大型程序中,声明异常的要求会在方法之间层层传播,方法签名因包含提供信息很少的 [throws] 子句而变得臃肿;
  • 由于不知道如何处理受检异常,许多程序员只是为了让编译器闭嘴而用空的 [catch] 块捕获它:错误悄无声息地消失了,这是最糟糕的结果;
  • 受检异常与 lambda(第 7 章)配合得不好:传给库函数的 lambda 如果不经过一番折腾,就无法抛出受检异常;
  • 最后,Java 生态系统中许多较新的库(Spring、Hibernate,我们稍后会用到)已经只使用非受检异常。在 Java 课程中,我们经常把受检异常包装在非受检异常中:在 Kotlin 中,这是不必要的。

代价是编译器不再提醒我们某个函数可能失败:需要由程序员自己知道函数可能抛出哪些异常(文档中会有说明),并在能够处理它们的地方捕获。

当需要从 Java 代码调用 Kotlin 函数时,[@Throws(IOException::class)] 注解会在字节码中生成 Java 编译器所期望的 [throws IOException] 子句。没有它,调用该函数并捕获 [IOException] 异常的 Java 程序会被 Java 编译器拒绝,因为后者认为该异常不可能发生([error: exception IOException is never thrown in body of corresponding try statement])。该注解对 Kotlin 调用者没有影响。

程序 [Basics23.kt] 涵盖了相应 Java 程序的各种情形:

// Kotlin 中没有受检异常
package basics23

import java.io.IOException
import java.io.UncheckedIOException
import java.nio.file.NoSuchFileException
import kotlin.io.path.Path
import kotlin.io.path.readText

fun main() {
    // 1 - readFile 可能抛出 IOException:我们捕获它,因为我们想这样做
    try {
        val content = readFile("missing.txt")
        println(content)
    } catch (e: IOException) {
        println("readFile : ${e.javaClass.name} - ${e.message}")
    }
    // 2 - Thread.sleep 可能抛出 InterruptedException:不要求使用 try
    pause(100)
    println("wait of 100 ms finished")
    // 3 - ArithmeticException 与任何异常一样,可以被捕获
    try {
        println("divide(1, 0) = ${divide(1, 0)}")
    } catch (e: ArithmeticException) {
        println("divide : ${e.javaClass.name} - ${e.message}")
    }
    // 4 - 被包装在另一个异常中的异常,后者添加了信息
    try {
        println(readConfiguration("absent.properties"))
    } catch (e: UncheckedIOException) {
        println("${e.message} ; cause : ${e.cause?.javaClass?.simpleName}")
    }
    // 5 - 几个异常在类层次结构中的位置
    println(ancestors(NoSuchFileException("x")))
    println(ancestors(NumberFormatException()))
    println(ancestors(OutOfMemoryError()))
}

// readText 抛出 IOException:对 Kotlin 来说无需声明,
// @Throws 为用 Java 编写的调用方声明它
@Throws(IOException::class)
fun readFile(name: String): String = Path(name).readText()

// Thread.sleep 抛出 InterruptedException:无需声明
fun pause(milliseconds: Long) {
    Thread.sleep(milliseconds)
}

// 整数除法可能抛出 ArithmeticException
fun divide(a: Int, b: Int): Int = a / b

// IOException 被捕获,然后包装在更明确的异常中重新抛出
fun readConfiguration(name: String): String {
    try {
        return Path(name).readText()
    } catch (e: IOException) {
        throw UncheckedIOException("unreadable configuration: $name", e)
    }
}

// 对象所属类的父类链
fun ancestors(o: Any): String {
    val chain = StringBuilder()
    var cls: Class<*>? = o.javaClass
    while (cls != null) {
        if (chain.isNotEmpty()) {
            chain.append(" -> ")
        }
        chain.append(cls.simpleName)
        cls = cls.superclass
    }
    return chain.toString()
}

结果:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics23.Basics23Kt
readFile : java.nio.file.NoSuchFileException - missing.txt
wait of 100 ms finished
divide : java.lang.ArithmeticException - / by zero
unreadable configuration: absent.properties ; cause : NoSuchFileException
NoSuchFileException -> FileSystemException -> IOException -> Exception -> Throwable -> Object
NumberFormatException -> IllegalArgumentException -> RuntimeException -> Exception -> Throwable -> Object
OutOfMemoryError -> VirtualMachineError -> Error -> Throwable -> Object

说明:

  • 第 41–42 行:扩展函数 [readText()] 来自包 [kotlin.io.path] (第 5 章),读取由路径 [Path] 指定的文件的全部内容;它可能抛出 [IOException]。函数 [readFile] 不拦截它,对 Kotlin 而言也无需声明任何内容。[@Throws] 注解是为潜在的 Java 调用者准备的;
  • 第 12–16 行:函数 [main] 拦截 [IOException] 是因为它自己选择这样做,而不是因为编译器要求。由于文件不存在,抛出的异常是 *[NoSuchFileException]*,这是派生自 *[IOException]* 的类,其消息为文件名;
  • 第 45–46 行:[Thread.sleep] 使程序暂停指定的毫秒数;它可能抛出 [InterruptedException],我们将在第 8 章讨论。在 Java 中,这是一个受检异常;在 Kotlin 中,函数 [pause] 无需任何声明;
  • 第 19 行:对 [pause] 的调用没有嵌套在 [try / catch] 之中。而相应的 Java 程序则必须这样做;
  • 第 50 行:整数除法可能抛出 [ArithmeticException];
  • 第 22–25 行:调用者捕获该异常是因为它自己选择这样做;
  • 第 53–57 行:在 Java 中,把 *[IOException] 包装在 *[UncheckedIOException] 中,可以使其不必出现在声明里。在 Kotlin 中,这个理由不再成立,但这种技术出于另一个原因仍然有用:新的异常为调用者携带了更明确的消息(“unreadable configuration”),而原始异常则作为原因传递给它;
  • 第 31 行:属性 [cause] (Java 方法 [getCause()])返回原始异常。它的类型是 [Throwable?]:因此要使用运算符 [?.];
  • 第 62–72 行:函数 [ancestors] 沿着对象的父类链向上遍历(属性 [superclass],即 Java 方法 [getSuperclass()]),一直到类 [Object],所有 Java 类的根。变量 [cls] 的类型是 [Class<*>?] (任意类型的类,或 [null]),因为对于类 [superclass] ,[null] 会得到 [Object];
  • 第 34–36 行:结果(最后三行)反映了上述层次结构。在 Kotlin 中,所有类的根是 [Any],它对应 Java 类 [Object]。

如果我们去掉注解 [@Throws] ,甚至去掉函数 [try / catch] 中的 [main],Kotlin 编译器仍然接受该程序。未捕获的异常会终止程序,程序会显示异常和调用栈,并以返回码 1 退出。这对于小型测试程序是可以接受的,但对真正的应用程序则不行。在本课程中,我们只在知道如何处理异常的地方捕获它。

3.6.6. 资源释放:use 函数

资源 (打开的文件、网络连接、数据库连接)在使用后必须关闭,即使在使用过程中发生了错误也是如此。可以在 [finally] 子句中关闭它,但这需要几行不易写对的代码。Java 7 为此引入了带资源的 **try([try (Type resource = ...) { ... }]*)。Kotlin 没有这种语法;它改用标准库中的一个简单函数,即 *[use] 函数:

1
2
3
resource.use { r ->
    use of the resource r
}

[use] 函数适用于任何其类型实现了 Java 接口 [AutoCloseable] (或从它派生的 [Closeable])的资源,该接口只包含方法 [close()];所有 Java 的文件、网络和数据库类都是如此。它执行传给它的块(一个 lambda,第 7 章),块的参数 [r] 指代该资源,然后关闭资源(通过调用其方法 [close()]),无论块是正常结束还是因异常结束。它返回块的值。如果省略参数名,则在块中以 [it] 指代该资源。

[use] 是一个扩展函数:它是用 Kotlin 编写的、位于 [AutoCloseable] 接口之外的函数,但调用起来就像是该接口的方法。我们将在第 4 章学习如何编写这样的函数。多个资源通过嵌套的 [use] 块来处理:最内层的资源最先关闭。[use] 可以放在 [try] 之内,并与 [catch] 和 [finally] 子句一起使用,这些子句在资源关闭之后执行。

我们前面提到,Kotlin 没有 Java 的多重捕获功能([catch (NumberFormatException | ArithmeticException e)])。要以相同方式处理多种异常类型,我们先捕获一个公共类型,然后使用 [when] 对异常进行分类。

程序 [Basics24.kt] 如下:

// use 函数取代了 Java 的 try-with-resources
package basics24

import java.io.StringReader

fun main() {
    // 1 - 离开 use 块时,资源会自动关闭
    openResource("R1").use { r ->
        println("using ${r.name}")
    }
    // 2 - 多个资源:嵌套的 use 调用。它们按与打开顺序相反的顺序关闭
    // 即使发生异常也是如此,并且在 catch 和 finally 子句之前
    try {
        openResource("R2").use { r2 ->
            openResource("R3").use { r3 ->
                println("using ${r2.name} and ${r3.name}")
                throw IllegalStateException("incident during use")
            }
        }
    } catch (e: IllegalStateException) {
        println("catch : ${e.message}")
    } finally {
        println("finally")
    }
    // 3 - BufferedReader 是一种资源
    StringReader("line 1\nline 2").buffered().use { reader ->
        while (true) {
            // 到达文本末尾时,readLine 返回 null
            val line = reader.readLine() ?: break
            println("read: $line")
        }
    }
    // 4 - use 返回其块的值
    val nbLines = StringReader("a\nb\nc").buffered().use { reader -> reader.readLines().size }
    println("number of lines: $nbLines")
    // 5 - 对多种异常类型采用相同的处理
    val operations = arrayOf(arrayOf("10", "2"), arrayOf("10", "zero"), arrayOf("10", "0"))
    for (operation in operations) {
        try {
            val a = operation[0].toInt()
            val b = operation[1].toInt()
            println("$a / $b = ${a / b}")
        } catch (e: RuntimeException) {
            when (e) {
                is NumberFormatException, is ArithmeticException ->
                    println("${operation.contentToString()} : ${e.javaClass.simpleName} - ${e.message}")
                // 其他异常被重新抛出
                else -> throw e
            }
        }
    }
}

// 资源:实现 AutoCloseable 接口的对象(第 4 章)
data class Resource(val name: String) : AutoCloseable {
    override fun close() {
        println("closing $name")
    }
}

fun openResource(name: String): Resource {
    println("opening $name")
    return Resource(name)
}

结果:

> gradlew -q run -Pmain=basics24.Basics24Kt
opening R1
using R1
closing R1
opening R2
opening R3
using R2 and R3
closing R3
closing R2
catch : incident during use
finally
read: line 1
read: line 2
number of lines: 3
10 / 2 = 5
[10, zero] : NumberFormatException - For input string: "zero"
[10, 0] : ArithmeticException - / by zero

说明:

  • 第 55–57 行:一个演示用的资源。这是一个数据类 (第 4 章),一个非常简单的类,其中每个对象都有一个名称;它实现了 [AutoCloseable] 接口,方法是重新定义([override])其 [close()] 方法,该方法会显示一条消息;
  • 第 61–63 行:函数 [openResource] 显示一条消息并创建一个资源;
  • 第 8–9 行:资源 [r] 在块结束时自动关闭(结果的第 4 行);
  • 第 14–17 行:两个资源,带有两个嵌套的 [use] 实例。在使用它们的过程中抛出了一个异常(第 17 行)。结果(第 5–11 行)表明,R3 先于 R2 关闭,并且两者都在执行 [catch] 和 [finally] 子句之前关闭;
  • 第 26 行:一个 [BufferedReader] ,这里它把字符串当作文件来读取。扩展函数 [buffered()] 创建一个 [BufferedReader] ,由 [StringReader] 得到,而无需写 [BufferedReader(StringReader(...))]。我们将在第 5 章读取真正的文件;
  • 第 29 行:[readLine()] 返回下一行,在文本末尾则返回 [null] 。在 Kotlin 中,赋值不是表达式:你不能像在 Java 中那样写 [while ((line = reader.readLine()) != null)]。运算符 [?:] 后跟 [break](类型为 [Nothing] 的表达式,如 [throw])会在 [readLine()] 的计算结果为 [null] 时退出循环。此时变量 [line] 的类型为 [String],它是不可为空的。在第 5 章中,我们将介绍无需循环即可读取所有行的函数([readLines]、[forEachLine]、[useLines]);
  • 第 34 行:[use] 在关闭读取器之后,返回其块的值——在这里是 [readLines()] 读取的行数;
  • 第 43–48 行:取代多重捕获块:捕获公共父类 [RuntimeException],然后由 [when] 对两个预期的类型应用相同的处理([when] 子句可以列出多个 [is] 测试,以逗号分隔)。其他异常会被重新抛出;意外的错误不会被抑制;
  • 第 46 行:[operation.contentToString()] 以“[10, zero]”的形式返回数组的内容,类似于 Java 中的 [Arrays.toString] 。属性 [e.javaClass.simpleName] 给出异常类的名称(结果的第 16 行和第 17 行)。

3.7. 示例应用程序 - V1

我们的目标是编写一个计算纳税人税款的程序。我们考虑一种简化的情形:纳税人只有一份工资需要申报。数字取自 2004 年针对 2003 年收入的税率表,并且原样使用:这是一道编程练习,而不是对当前税款的计算。该应用程序将作为我们的主线:在后面的章节中我们还会回到它,逐步加入类、文件、数据库、协程,最终加入网络功能。

  • 我们计算该雇员的份数:如果雇员未婚,份数 = nbChildren/2 + 1,如果已婚,份数 = nbChildren/2 + 2,其中 nbChildren 是子女数;
  • 如果他至少有三个孩子,则额外获得半份;
  • 他的应纳税所得额 R 的计算公式为 R = 0.72 * S,其中 S 是他的年薪;
  • 他的家庭系数的计算公式为 QF = R / 份数;
  • 他的税款 I 按下表计算:
上限
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

每一行有 3 个字段。要计算税款 I,需找到第一个 QF 小于或等于上限的行。例如,如果 QF = 5,000,则找到的行将是:

8382    0.068    291.09

于是税款 I 等于 0.068 * R - 291.09 * 份数,四舍五入到最接近的整数欧元。如果 QF 使得条件 QF <= 上限始终不满足,则使用最后一行的系数:I = 0.481 * R - 9505.54 * 份数。因此,最后一行中的上限 0 永远不会被使用。

计算涉及金额和小数系数:我们使用 Java 类 [BigDecimal] 来进行,Kotlin 直接使用它——而且比 Java 更方便:Kotlin 标准库定义了运算符 [+]、[-]、[*],以及比较运算符 [<], [>]……适用于任何可比较的对象。对应的 Kotlin 程序 [Tax1.kt] 如下:

// 税款计算 - 版本 1
// 2004 年税率表(2003 年收入):这是一道练习题,不是当前的税率表
package tax1

import java.math.BigDecimal
import java.math.MathContext

fun main() {
    // 税款计算所需的数据数组
    val limits = decimals("4962", "8382", "14753", "23888", "38868", "47932", "0")
    val coeffR = decimals("0", "0.068", "0.191", "0.283", "0.374", "0.426", "0.481")
    val coeffN = decimals("0", "291.09", "1322.92", "2668.39", "4846.98", "6883.66", "9505.54")

    // 婚姻状况
    val married = readMaritalStatus()
    // 子女数量
    val nbChildren = readPositiveInteger("Number of children: ")
    // 年薪
    val salary = readPositiveInteger("Annual salary: ")

    // 份数
    var shares = nbChildren.toBigDecimal().divide(BigDecimal.TWO) + (if (married) 2 else 1).toBigDecimal()
    if (nbChildren >= 3) {
        shares += BigDecimal("0.5")
    }

    // 应税收入
    val income = BigDecimal("0.72") * salary.toBigDecimal()

    // 家庭系数(除法可能不是精确的:设定了精度)
    val quotient = income.divide(shares, MathContext.DECIMAL128)

    // 查找税率档:第一个满足 quotient <= limit 的档,
    // 如果都不符合则取最后一个
    var i = 0
    while (i < limits.size - 1 && quotient > limits[i]) {
        i++
    }

    // 税额(舍去到整欧元)
    val tax = (coeffR[i] * income - coeffN[i] * shares).toInt()

    // 显示结果
    println("Tax to pay: $tax euros")
}

// 显示提示,读取一行并返回,去除首尾空格
// (如果输入流已耗尽则返回空字符串)
fun read(prompt: String): String {
    print(prompt)
    return (readlnOrNull() ?: "").trim()
}

// 询问婚姻状况,直到得到正确的答案
fun readMaritalStatus(): Boolean {
    while (true) {
        when (read("Are you married (Y/N)? ").lowercase()) {
            "y" -> return true
            "n" -> return false
            else -> System.err.println("Incorrect answer. Try again")
        }
    }
}

// 询问一个正整数或零,直到得到正确的答案
fun readPositiveInteger(prompt: String): Int {
    while (true) {
        // 如果输入不是整数,toIntOrNull 返回 null:无需处理异常
        val number = read(prompt).toIntOrNull()
        if (number != null && number >= 0) {
            return number
        }
        System.err.println("Incorrect answer. Try again")
    }
}

// 将字符串转换为精确的 BigDecimal 数字
fun decimals(vararg values: String): Array<BigDecimal> =
    Array(values.size) { i -> BigDecimal(values[i]) }

说明:

  • 第 10–12 行:三个 [BigDecimal] 数组由函数 [decimals] (第 78–79 行)根据字符串构造:因此每个值(如 0.068)都是精确的。如果使用 [Double],0.068 只是一个二进制近似值。函数 [decimals] 接受任意数量的参数([vararg values: String]),它以数组形式接收这些参数;这种写法将在“向函数传递参数”一节中解释。结果数组由 [Array(size) { i -> value }] 构造,它根据下标计算每个元素;
  • 第 15 行:婚姻状况的输入由函数 [readMaritalStatus] (第 55–60 行)处理。Java 程序在其方法 [main] 中完成所有输入,使用的是不带初值而声明的变量;在 Kotlin 中,每个输入都是一个返回所输入值的函数,因此变量 [married]、[nbChildren] 和 [salary] 可以声明为 [val];
  • 第 49 行:函数 [read] 使用 [print] (不换行)显示提示并读取回答;如果输入流已关闭,则 [null] 由 [readlnOrNull] 返回的值会被替换为空字符串。函数 [trim()] 删除所读取字符串的前导和尾随空格;
  • 第 56–60 行:一个 [while (true)] 循环,当回答正确时通过 [return] 退出。[when] 作用于经 [lowercase()] 转换为小写的回答:这使得 Y 和 y 都能被接受。在 Kotlin 中,字符串使用 [==] 运算符比较,它比较的是内容([when] 正是这样做的);不需要 Java 方法 [equals];
  • 第 60 行:错误消息被写入 [System.err] 流;
  • 第 66–73 行:输入一个正整数或零,用于子女数和工资:Java 程序把同样的循环重复了两次。[toIntOrNull()] 在输入不是整数时返回 [null] :既不需要 [try],也没有需要处理的异常。第 70 行,在 [number != null] 测试之后,编译器知道 [number] 不是 [null]:它接受比较 [number >= 0] 以及指令 [return number] (在返回类型为 [Int] 的函数中,这是智能类型转换);
  • 第 22 行:份数按 [BigDecimal] 计算。你不能简单地写 [nbChildren / 2]:如果 nbChildren 为 3,你会得到 3/2,这是整数除法,结果为 1 而不是 1.5。扩展函数 [toBigDecimal()] 转换该整数,[divide(BigDecimal.TWO)] 将其精确地除以二,运算符 [+] 再加上 2 或 1,这由表达式 [if] 确定。注意:当 Kotlin 运算符 [/] 应用于 [BigDecimal] 时,会保留被除数的小数位数并对结果进行舍入:[3.toBigDecimal() / 2.toBigDecimal()] 的结果是 2,而不是 1.5。对于涉及 [BigDecimal] 的除法,应始终使用 [divide] 方法;
  • 第 24 行:[BigDecimal] 是不可变的:运算符 [+=] 不会修改对象;它创建一个新对象 [shares + BigDecimal("0.5")] 并将其赋给变量,因此 [shares] 被声明为 [var]。在 Java 中,你必须写 [shares = shares.add(...)],而忘记赋值是一个经典的陷阱;
  • 第 28 行:应纳税所得额,使用运算符 [*] 计算;
  • 第 31 行:家庭系数。将收入除以 1.5 或 3.5 份,通常不会得到有限小数表示:我们设置一个精度,这里是 [MathContext.DECIMAL128] (34 位有效数字),这已经绰绰有余;
  • 第 35–37 行:确定税率档。搜索在第一个大于或等于家庭系数的上限处停止,且不会超过最后一个税率档,使用的条件是 [i < limits.size - 1]。在 Kotlin 中,运算符 [>] 适用于 [BigDecimal]:[quotient > limits[i]] 会被编译器翻译为 [quotient.compareTo(limits[i]) > 0],这正是我们在 Java 中会写的方式。不过,我们不会对两个 [BigDecimal] 表达式 使用 [==] 比较,因为它会调用 [equals] 并考虑小数位数:对于 [equals] 来说,2.0 和 2.00 并不“相等”;
  • 第 41 行:税款由函数 [toInt()] 截断到最接近的整数欧元,它会丢弃小数部分。

以下是一些输出示例(在键盘上输入的内容已包含在显示中):

1
2
3
4
5
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
1
2
3
4
5
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

对于年薪 60,000 欧元的情形,已婚且有 2 个孩子的纳税人缴纳 4,282 欧元,有 3 个孩子的缴纳 2,959 欧元,没有孩子的单身者缴纳 11,519 欧元:这些是 Java 版本的结果。在第二次运行中,输入“60000 euros”被拒绝:[toIntOrNull] 只接受表示精确整数的字符串(前导和尾随空格已由 [trim()] 删除)。

3.8. 主程序参数

主函数 [main] 可以接受字符串数组 [Array<String>] 作为参数。该数组包含启动应用程序所用的命令行参数。因此,如果我们用如下命令启动程序 P:

java -jar P.jar arg0 arg1 ... argn

并且函数 [main] 声明如下:

fun main(args: Array<String>) {

那么我们将得到 args[0]="arg0"、args[1]="arg1",依此类推。当程序不需要参数时,我们只需写 [fun main()],就像我们到目前为止所做的那样。使用 Gradle 时,传给程序的参数由任务 [run] 通过选项 [--args] 接收,形式为用引号括起来的单个字符串;Gradle 自己的选项(如 [-q] 或 [-P])则放在它旁边:

gradlew -q run -Pmain=package.ProgKt --args="a0 a1 a2"

对于 IntelliJ 和 IDEA,参数在程序的运行配置中输入(在“Program arguments”字段中)。

下面是一个示例 [Basics25.kt]:

1
2
3
4
5
6
7
8
9
// 命令行参数
package basics25

fun main(args: Array<String>) {
    println("There are ${args.size} argument(s)")
    for (i in args.indices) {
        println("args[$i]=${args[i]}")
    }
}

结果:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics25.Basics25Kt --args="a0 a1 a2 a3"
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

包含空格的参数必须用引号括起来;在字符串 [--args] 中,使用单引号:

1
2
3
4
> gradlew -q run -Pmain=basics25.Basics25Kt --args="'jean dupont' 23"
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

如果没有参数,数组 [args] 为空;它永远不会等于 [null]:

> gradlew -q run -Pmain=basics25.Basics25Kt
There are 0 argument(s)

说明:

  • 第 4 行:程序的入口点。编译器生成一个类 [Basics25Kt] ,其中包含方法 [public static void main(String[] args)]:这正是标准的 Java 入口点;
  • 第 5 行:数组的大小由其 [size] 属性指定(在 Java 中是 [length] 字段);
  • 第 6–7 行:遍历数组下标。

在 Java 中,标准的 [main] 方法是类的静态方法。Kotlin 没有静态方法;不过,如果你希望入口点是具有特定名称的类(例如某个工具要求如此),可以把函数 [main] 放在一个对象中,该对象用关键字 [object] (第 4 章)声明,并用 [@JvmStatic] 注解它。程序 [Basics26.kt] 就是这样做的:

// main 函数放在对象中时的命令行参数
package basics26

object Basics26 {
    @JvmStatic
    fun main(args: Array<String>) {
        println("There are ${args.size} argument(s)")
        for ((i, arg) in args.withIndex()) {
            println("args[$i]=$arg")
        }
    }
}

结果:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics26.Basics26 --args="a0 a1 a2 a3"
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

说明:

  • 第 4 行:一个 [Basics26] 对象。编译器生成一个 [Basics26] 类,且只有一个对象;
  • 第 5–6 行:注解 [@JvmStatic] 指示编译器使 [main] 成为类 [Basics26] 的静态方法,这正是 Java 虚拟机所期望的。因此要执行的类是 [basics26.Basics26],而不是 [basics26.Basics26Kt];
  • 第 8–9 行:使用函数 [withIndex()] 遍历数组,该函数同时返回下标和元素。

这种形式在 Kotlin 中很少见:位于任何类之外的顶层函数 [main]才是常规做法。最后请注意,与 Java 一样,函数 [main] 不返回值:程序的退出码通过 [exitProcess] 设置。

3.9. 枚举

枚举是一种数据类型,其值域由一组具名常量构成。考虑一个需要处理考试成绩评语的程序。共有五种可能的评语:Pass、Fairly Good、Good、Very Good 和 Excellent。于是我们可以为这五个常量定义一个枚举:

enum class Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

Kotlin 写作 [enum class]***,而 Java 写作 [enum]*:[enum] 不是保留关键字,而是类声明的一个修饰符** 。按照惯例,常量名用大写字母书写。可以声明一个变量,使其取值来自该枚举:

    val myHonours = Honours.PASS

可以使用 == 运算符将变量与枚举中各个可能的值进行比较:

1
2
3
    if (myHonours == Honours.PASS) {
        println("Could do better")
    }

与 Java 一样,而与其他把枚举仅仅当作一组具名整数的语言不同,Kotlin 的枚举是一个类,被编译为派生自 [java.lang.Enum] 的类,其仅有的对象就是所声明的常量。每个常量都是唯一的对象,一次性创建。每个常量都知道自己的名称(属性 [name],或 [toString()])以及它在声明中的序号(属性 [ordinal],从 0 开始)。常量按此顺序是可比较的:你可以写 [m1 < m2]。每个枚举还具有:

  • [Honours.entries]:[Honours] 枚举中按声明顺序排列的常量(不可修改的)列表。它是 [Honours.values()] 函数的更好替代方案——该函数继承自 Java,仍然可用——但每次调用都会创建一个新数组;
  • [Honours.valueOf(name)]:返回名为 [name] 的常量,如果没有常量具有该名称,则抛出 [IllegalArgumentException] 。

枚举不能转换为整数,整数也不能转换为枚举:我们使用 [ordinal] 和 [entries]。

程序 [Basics27.kt] 演示了刚才所描述的内容:

// 枚举
package basics27

enum class Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

fun main() {
    // 取值来自 Honours 枚举的变量
    val myHonours = Honours.PASS
    // 显示变量的值
    println("honours=$myHonours")
    // 用枚举的一个值进行测试
    if (myHonours == Honours.PASS) {
        println("Could do better")
    }
    // 荣誉列表:名称和序号
    for (m in Honours.entries) {
        println("${m.name} = ${m.ordinal}")
    }
    // 序号 → 枚举
    val m3 = Honours.entries[3]
    println("Honours.entries[3] = $m3")
    // 字符串 → 枚举
    val m2 = Honours.valueOf("GOOD")
    println("m2=$m2, m2 after PASS : ${m2 > Honours.PASS}")
    try {
        Honours.valueOf("Good")
    } catch (e: IllegalArgumentException) {
        println("valueOf(\"Good\") : ${e.message}")
    }
    // 不抛异常:如果字符串不是常量名则返回 null
    val m4 = Honours.entries.find { it.name == "Good" }
    println("m4=$m4")
    // when 表达式中的枚举:如果处理了所有情况,则不需要 else
    val assessment = when (myHonours) {
        Honours.PASS, Honours.FAIRLY_GOOD -> "correct"
        Honours.GOOD, Honours.VERY_GOOD -> "very correct"
        Honours.EXCELLENT -> "remarkable"
    }
    println("assessment : $assessment")
    println("type : ${Honours::class.java.name}")
    println("parent class : ${Honours::class.java.superclass.name}")
}

结果:

> gradlew -q run -Pmain=basics27.Basics27Kt
honours=PASS
Could do better
PASS = 0
FAIRLY_GOOD = 1
GOOD = 2
VERY_GOOD = 3
EXCELLENT = 4
Honours.entries[3] = VERY_GOOD
m2=GOOD, m2 after PASS : true
valueOf("Good") : No enum constant basics27.Honours.Good
m4=null
assessment : correct
type : basics27.Honours
parent class : java.lang.Enum

说明:

  • 第 4 行:枚举声明。它位于文件顶部,与函数并列;或者,像类一样(第 4 章),它也可以声明在自己的文件 [Honours.kt] 中;
  • 第 8 行:一个类型为 [Honours] 的变量,其类型由所赋的值推断;
  • 第 10 行:枚举常量按名称列出;
  • 第 16–17 行:常量列表、它们的名称及其序号;
  • 第 20 行:将序号转换为常量:[entries] 是一个列表,可以像数组一样按下标索引;
  • 第 23 行:将字符串转换为枚举常量;
  • 第 24 行:常量根据其声明顺序进行比较:GOOD 排在 PASS 之后。运算符 [>] 被编译器翻译为对方法 [compareTo] 的调用,而在 Java 中则必须手工写出这个调用;
  • 第 25–28 行:[valueOf] 区分大小写:“Good”不是常量名。异常消息给出了枚举的完整名称 [basics27.Honours];
  • 第 31 行:为了避免异常,可以在 [entries] 中使用函数 [find] 搜索该常量,它返回第一个满足花括号之间所写条件的元素(一个 lambda,第 7 章;其中 [it] 表示正在检查的元素),如果没有则返回 [null] ;
  • 第 34–37 行:枚举非常适合与 [when] 表达式配合使用。由于所有常量都被处理了,该表达式无需 [else] 子句也是穷尽的。如果以后向枚举中添加了常量,编译器会拒绝已变得不完整的 [when] 表达式,并指出被遗漏的常量。例如,去掉第 37 行:[error: 'when' expression must be exhaustive. Add the 'EXCELLENT' branch or an 'else' branch.]。这是一个很好的理由:不要为枚举加入 [else] 子句——即在 [when] 中。与 Java 的 [switch] 不同,常量带有枚举名前缀;语句 [import basics27.Honours.*] 则允许单独书写它们的名称;
  • 第 40 行:该枚举的完整名称是 [basics27.Honours]:它在文件级别声明,位于 [basics27] 包中。[Honours::class.java] 是该枚举的 Java 类;
  • 第 41 行:任何枚举的父类都是 [java.lang.Enum]。

3.9.1. 增强枚举

由于枚举是一个类,它可以有属性、构造函数和方法。Kotlin 使这一点特别简洁:属性使用 [val] 在枚举名称后面的圆括号内声明(即主构造函数,第 4 章),每个常量通过用其名称后圆括号内所写的值调用该构造函数来创建。这是一个被广泛使用的特性,它无需再管理与常量相关联的独立值数组。

为了表示一组选项,例如文件访问权限(读、写、执行),人们过去常常用 [or] 运算符(按位或)组合 2 的幂。现在我们改用枚举和 Java 类 [EnumSet],它是某个枚举的常量集合,与按位组合一样高效(其内部就是按位组合),但可读性要好得多。[EnumMap] 类同样是一个字典,其键是枚举的常量。Kotlin 直接使用它们。

程序 [Basics28.kt] 如下:

// 增强的枚举:属性、构造函数、方法;EnumSet 和 EnumMap
package basics28

import java.util.EnumMap
import java.util.EnumSet

// 每个荣誉都有一个最低分数和一个标签
enum class Honour(val minimumGrade: Int, val label: String) {
    PASS(10, "Pass"),
    FAIRLY_GOOD(12, "Fairly good"),
    GOOD(14, "Good"),
    VERY_GOOD(16, "Very good"),
    EXCELLENT(18, "Excellent");

    // 方法:下一个荣誉(最后一个则为 null)
    fun next(): Honour? = entries.getOrNull(ordinal + 1)

    // 枚举自身的函数:与某个分数对应的荣誉(如果 grade < 10 则为 null)
    companion object {
        fun forGrade(grade: Double): Honour? = entries.lastOrNull { grade >= it.minimumGrade }
    }
}

// 访问权限:一组值将用 EnumSet 表示
enum class Permission { READ, WRITE, EXECUTE }

fun main() {
    for (m in Honour.entries) {
        println("$m : \"${m.label}\" from ${m.minimumGrade}, next : ${m.next()}")
    }
    val grades = doubleArrayOf(8.5, 12.0, 15.5, 19.0)
    for (grade in grades) {
        val label = Honour.forGrade(grade)?.label ?: "no honours"
        println("grade $grade : $label")
    }

    // EnumSet:枚举值的集合(取代位组合)
    val permissions = EnumSet.of(Permission.READ, Permission.WRITE)
    println("permissions=$permissions, read : ${Permission.READ in permissions}, execute : ${Permission.EXECUTE in permissions}")
    permissions.add(Permission.EXECUTE)
    permissions.remove(Permission.WRITE)
    println("permissions=$permissions")
    println("all=${EnumSet.allOf(Permission::class.java)}, none=${EnumSet.noneOf(Permission::class.java)}" +
            ", complement of [READ]=${EnumSet.complementOf(EnumSet.of(Permission.READ))}")
    println("from FAIRLY_GOOD to VERY_GOOD : ${EnumSet.range(Honour.FAIRLY_GOOD, Honour.VERY_GOOD)}")

    // EnumMap:键为枚举值的字典(第 5 章)
    val headcounts = EnumMap<Honour, Int>(Honour::class.java)
    headcounts[Honour.GOOD] = 7
    headcounts[Honour.PASS] = 12
    println("headcounts=$headcounts")
}

结果:

> gradlew -q run -Pmain=basics28.Basics28Kt
PASS : "Pass" from 10, next : FAIRLY_GOOD
FAIRLY_GOOD : "Fairly good" from 12, next : GOOD
GOOD : "Good" from 14, next : VERY_GOOD
VERY_GOOD : "Very good" from 16, next : EXCELLENT
EXCELLENT : "Excellent" from 18, next : null
grade 8.5 : no honours
grade 12.0 : Fairly good
grade 15.5 : Good
grade 19.0 : Excellent
permissions=[READ, WRITE], read : true, execute : false
permissions=[READ, EXECUTE]
all=[READ, WRITE, EXECUTE], none=[], complement of [READ]=[WRITE, EXECUTE]
from FAIRLY_GOOD to VERY_GOOD : [FAIRLY_GOOD, GOOD, VERY_GOOD]
headcounts={PASS=12, GOOD=7}

说明:

  • 第 8 行:枚举及其主构造函数。关键字 [val] 使 [minimumGrade] 和 [label] 成为每个常量的只读属性 。Java 程序则必须声明两个名为 [private final] 的字段,编写初始化它们的构造函数,然后编写两个方法 [getMinimumGrade] 和 [getLabel] 来读取它们:Kotlin 会生成所有这些。枚举的构造函数是私有的:你不能创建额外的常量;
  • 第 9–13 行:枚举的常量,每个常量带有两个参数。当最后一个常量之后还有成员时,其后的分号是必需的:这是 Kotlin 中极少数必须使用分号的地方之一;
  • 第 16 行:一个作用于常量的方法([m.next()])。它使用常量的属性 [ordinal] 和列表 [entries];[getOrNull] 返回给定下标处的元素,如果下标越界则返回 [null] :最后一个常量没有后继。返回类型 [Honour?] 表明了这一点;
  • 第 19–20 行:一个在枚举本身上调用的函数([Honour.forGrade(grade)]),类似于 Java 中的静态方法。Kotlin 没有静态方法:它们被放在类的 伴生对象 ([companion object])中,将在第 4 章介绍。由于常量按分数升序声明,满足最低分数要求的最后一个常量就是正确的那个:[lastOrNull] 返回列表中最后一个满足条件的元素,如果没有则返回 [null] 。结果的类型是 [Honour?],如果分数低于 10,则为 [null] :Java 使用 [Optional] 的地方,Kotlin 使用可空类型;
  • 第 25 行:一个表示访问权限的简单枚举;
  • 第 28–29 行:带有其属性的条目列表:我们写 [m.label],而不是 [m.getLabel()];
  • 第 31 行:一个实数数组 [DoubleArray]。分数写成 12.0 和 19.0,而不是 12 和 19:Kotlin 不会将 [Int] 隐式转换为 [Double];
  • 第 33 行:只有当 [Honour.forGrade(grade)] 不为 [null] 时,运算符 [?.] 才会读取属性 [label];否则运算符 [?:] 返回一段文本。这等价于 Java 的 [map(Honour::getLabel).orElse("no honours")];
  • 第 38 行:一个包含两项权限的集合;
  • 第 39 行:运算符 [in] 检查某个常量是否属于该集合,就像检查某一位一样。编译器会把它翻译为对方法 [contains] 的调用;
  • 第 40–41 行:向集合中添加常量以及从集合中移除常量;
  • 第 43–44 行:所有常量的集合、空集合以及集合的补集。[Permission::class.java] 是该枚举的 Java 类,这些 Java 方法会用到它(在 Java 中为 [Permission.class] );
  • 第 45 行:两个常量之间的常量,按其声明顺序排列;
  • 第 48–50 行:[EnumMap] 将一组元素与某些条目关联起来。写法 [headcounts[key] = value] 取代了调用 [headcounts.put(key, value)]。[EnumMap] 的键总是按常量的声明顺序遍历:PASS 出现在 GOOD 之前,尽管它是后添加的。字典将在第 5 章讨论。

3.10. 向函数传递参数

在 Kotlin 中,函数可以声明在文件的顶层,位于任何类之外,就像我们的 [main] 函数一样:这些函数称为顶层函数。在类内部声明的函数是方法 (第 4 章)。这里我们将重点讨论参数是如何传递给函数的。考虑如下函数:

1
2
3
fun changeInt(a: Int) {
    println("Formal parameter a=$a")
}

在函数定义的第 1 行中,[a] 被称为形式参数。它仅为函数定义 [changeInt] 而存在。它同样可以命名为 [b]。它的类型是必需的:类型推断不适用于参数。现在让我们来看这个函数的一次调用:

1
2
3
    val age = 20
    changeInt(age)
    println("Actual parameter age=$age")

这里,在第 2 行的语句中,[age] 是实际参数(也称为实参),它会把自己的值传递给形式参数 [a]。我们关心的是形式参数如何获取实际参数的值。

3.10.1. 按值传递与不可变参数

与 Java 一样,Kotlin 只有一种参数传递方式:按值传递。实际参数的值被复制到相应的形式参数中。这是两个不同的实体。

Kotlin 比 Java 更进一步:形式参数始终是 [val]。在函数内部不能给它赋新值;就好像在 Java 中所有参数都被声明为 [final]。因此,“函数能否通过修改形式参数来修改实际参数?”这个问题根本不会出现。如果函数需要一个会被修改的变量,它会声明一个用参数值初始化的局部变量。

当参数是数组或对象时,传递的值是指向该对象的引用 :此时形式参数和实际参数引用同一个对象。因此,如果该对象是可变的,函数可以修改它,调用者将看到这一变化;但是,函数不能使调用者的变量引用另一个对象。

Kotlin 不支持按引用传递,即形式参数和实际参数是同一个变量(例如 C# 中的参数 [ref] 和 [out] ):函数不能修改调用者的局部变量,也不能通过其参数向调用者“返回”结果。我们改用:

  • 函数的返回值,由调用者将其赋给自己的变量;
  • 当函数需要返回多个值时,使用数据类 或元组 ([Pair]、[Triple]);
  • 作为参数传入的数组 或可变对象 ,函数把结果放入其中。

程序 [Basics29.kt] 演示了这些不同的情形:

// 参数传递:始终按值传递,且参数是 val
package basics29

import java.math.BigDecimal

fun main() {
    // 1 - 按值传递:实参不会被修改
    val age = 20
    changeInt(age)
    println("Actual parameter age=$age")

    // 2 - 要修改调用方的变量:函数返回新值
    var age2 = 20
    age2 = changeInt2(age2)
    println("Actual parameter age2=$age2")

    // 3 - 要返回多个值:使用数据类
    val c1 = convert("123")
    val c2 = convert("12x")
    println("c1=$c1, c2=$c2")
    if (c1.succeeded) {
        println("value of c1 : ${c1.value}")
    }

    // 4 - 值的交换:将值存放在数组中
    val xy = intArrayOf(1, 2)
    swap(xy)
    println("after swap : x=${xy[0]}, y=${xy[1]}")
    // 交换两个局部变量,不使用函数或临时变量
    var x = 1
    var y = 2
    x = y.also { y = x }
    println("after swap : x=$x, y=$y")

    // 5 - 按值传递的数组:被复制的是它的引用
    val array = intArrayOf(1, 2, 3)
    modifyArray(array)
    println("array=${array.contentToString()}")

    // 6 - 可修改(可变)的对象:函数修改被引用的对象
    val message = StringBuilder("Hello")
    complete(message)
    println("message=$message")

    // 7 - 参数不能在函数中接收新值
    val price = BigDecimal("100")
    println("InclTax($price)=${inclTax(price)}")
}

// 转换的结果:是否成功以及得到的值
data class Conversion(val succeeded: Boolean, val value: Int)

fun changeInt(a: Int) {
    // a = 30 会被拒绝:参数是 val。我们操作的是局部副本
    var copy = a
    copy += 10
    println("Formal parameter a=$a, local copy=$copy")
}

fun changeInt2(a2: Int): Int {
    println("Formal parameter a2=$a2")
    return a2 + 10
}

fun convert(text: String): Conversion =
    try {
        Conversion(true, text.toInt())
    } catch (_: NumberFormatException) {
        Conversion(false, 0)
    }

fun swap(t: IntArray) {
    val temp = t[0]
    t[0] = t[1]
    t[1] = temp
}

fun modifyArray(t: IntArray) {
    // 我们修改被引用的数组:调用方可以看到该修改
    t[0] = 100
    // t = intArrayOf(7, 8, 9) 会被拒绝:不能让 t 指向另一个数组
    println("in modifyArray : t=${t.contentToString()}")
}

fun complete(text: StringBuilder) {
    text.append(" everyone")
}

fun inclTax(amount: BigDecimal): BigDecimal {
    // amount = BigDecimal.ZERO 会被拒绝:参数是 val
    return amount * BigDecimal("1.2")
}

结果:

> gradlew -q run -Pmain=basics29.Basics29Kt
Formal parameter a=20, local copy=30
Actual parameter age=20
Formal parameter a2=20
Actual parameter age2=30
c1=Conversion(succeeded=true, value=123), c2=Conversion(succeeded=false, value=0)
value of c1 : 123
after swap : x=2, y=1
after swap : x=2, y=1
in modifyArray : t=[100, 2, 3]
array=[100, 2, 3]
message=Hello everyone
InclTax(100)=120.0

说明:

  • 第 8–10 行:实际参数 [age] 的值 20 被复制到形式参数 [a] 中(第 53 行)。函数不能修改 [a]:它创建一个局部副本 [copy] (第 55 行),然后修改这个副本。实际参数保持不变;
  • 第 13–15 行:函数 [changeInt2] (第 60–62 行)返回一个新值,调用者把它赋给自己的变量 [age2],为此该变量声明为 [var] ;
  • 第 51 行:数据类 ([data class])用一行代码声明了一个类,其对象由两个不可变的值 [succeeded] 和 [value] 组成。编译器会自动添加(除其他内容外)一个名为 [toString()] 的方法,它显示各个组成部分,以及方法 [equals()] 和 [hashCode()]。这是 Kotlin 中与 Java 记录等价的东西;数据类将在第 4 章介绍。它的组成部分是属性:我们写 [c1.succeeded],而不是 [c1.succeeded()] ,这与记录不同;
  • 第 18–22 行:函数 [convert] (第 65–69 行)返回两项信息——转换是否成功以及转换得到的值——它们被合并到单个 [Conversion] 对象中。它的函数体是一个 [try] 表达式,其计算结果是两个 [Conversion] 对象之一。请注意,在 Kotlin 中,通常会写一个类型为 [Int?] 的函数,在失败时返回 [null] :这正是 [toIntOrNull()] 所做的;
  • 第 26–28 行:交换两个值。形如 [swap(a: Int, b: Int)] 的函数对调用者毫无用处;因此,这两个值存放在一个数组中,由函数 [swap] (第 72–75 行)修改它;
  • 第 30–32 行:要交换两个局部变量,Kotlin 提供了一种惯用写法:[x = y.also { y = x }]。函数 [also] 执行块,块把 [x] 的值赋给 [y],然后返回块执行之前 [y] 的值,该值被赋给 [x]。诸如 [also] 之类的函数将在第 7 章介绍;
  • 第 36–38 行:数组引用是按值传递的。因此函数 [modifyArray] 操作的是与调用者相同的数组:由 [t[0]] (第 80 行)所做的修改对调用者是可见的。但是,不可能让 [t] 指向另一个数组:[t] 是一个 [val];
  • 第 41–43 行:[StringBuilder] 对象是可变字符串:函数 [complete] (第 85–86 行)向其追加文本,调用者能看到结果。如果是 [String],这就不可能了:[String] 对象是不可变的;
  • 第 46–47 行:函数 [inclTax] (第 89–91 行)计算含税价格。两个 [BigDecimal] 对象 的乘积,其小数位数等于两个因数小数位数之和:100 × 1.2 = 120.0,显示为 120.0。

如果把第 90 行的注释替换为 [amount = BigDecimal.ZERO] 语句,编译器会拒绝该程序:

1
2
3
error: 'val' cannot be reassigned.
    amount = BigDecimal.ZERO
    ^^^^^^

3.10.2. 默认值、命名参数、重载、可变数量的参数

Java 既没有可选参数,也没有命名参数,必须通过方法重载来模拟它们:同一方法的多个版本,其中简短的版本使用默认值调用完整的版本。Kotlin 与 C# 一样,两者都有:

  • 参数可以有默认值:[fun greet(name: String, greeting: String = "Hello")]。这样,调用者就可以省略相应的实际参数:[greet("Pierre")];
  • 调用方法时,实参可以是命名的:[greet("Pierre", upperCase = true)]。这样可以省略某个有默认值的参数而传递其后的参数,可以按任意顺序传递实参,最重要的是,使调用更具可读性:[upperCase = true] 比在实参列表中孤立出现的 [true] 更清晰。

默认值和命名参数使大多数重载——以及 Java 的“构建器”——变得不再必要。不过,重载 在 Kotlin 中确实存在:如果多个函数的参数列表在参数个数或类型上不同,它们可以同名;编译器根据实际参数选择合适的那个。当处理方式取决于参数的类型时,就会用到它。为了让带默认参数的 Kotlin 函数可以从 Java 中以较少的实参调用,[@JvmOverloads] 注解会指示编译器生成相应的重载。

最后,函数可以有可变数量的参数:在形式参数前加上关键字 [vararg],如 [vararg numbers: Int]。调用者可以传递一个值列表——可以为空——编译器会把它们组织成一个数组;在函数内部,该参数是一个数组(对于 [IntArray] 是 [Int],对于 [Array<String>] 是 [String]……)。与 Java 不同,你不能直接传递数组来代替值列表:必须使用展开运算符([*])将其“展开”,即 [sum(*values)],这还允许你混合使用数组和单个值。

程序 [Basics30.kt] 如下:

// 默认值、命名参数、重载、可变数量的参数
package basics30

fun main() {
    // 带默认值的参数:一个函数就够了
    println(greet("Pierre"))
    println(greet("Pierre", "Good evening"))
    // 命名参数:我们传入 upperCase 而不传入 greeting
    println(greet("Pierre", upperCase = true))
    // 所有参数都命名,顺序任意
    println(greet(upperCase = true, greeting = "Hi", name = "Paul"))

    // 重载:多个同名函数,根据参数类型选择
    describe(12)
    describe(12.5)
    describe("twelve")

    // vararg:可变数量的参数
    println("sum()=${sum()}")
    println("sum(1, 2, 3)=${sum(1, 2, 3)}")
    val values = intArrayOf(10, 20, 30)
    // * 运算符展开数组的元素
    println("sum(*values)=${sum(*values)}")
    println("sum(1, *values, 100)=${sum(1, *values, 100)}")
    // 带可变数量参数的 Kotlin 和 JDK 函数
    println(listOf(1, 2, 3, 4))
    println("%s, %s and %s".format("one", "two", "three"))
    println(maxOf(3, 9, 4, 7))
    println(setOf("a", "b", "a", "c"))
}

// 其中两个参数带有默认值的函数
fun greet(name: String, greeting: String = "Hello", upperCase: Boolean = false): String {
    val message = "$greeting $name"
    return if (upperCase) message.uppercase() else message
}

// 三个同名函数,区别在于其参数的类型
fun describe(n: Int) = println("$n is an integer")

fun describe(x: Double) = println("$x is a real")

fun describe(s: String) = println("\"$s\" is a string of ${s.length} characters")

fun sum(vararg numbers: Int): Int {
    // numbers 是一个整数数组(IntArray)
    var sum = 0
    for (number in numbers) {
        sum += number
    }
    return sum
}

结果:

> gradlew -q run -Pmain=basics30.Basics30Kt
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
12 is an integer
12.5 is a real
"twelve" is a string of 6 characters
sum()=0
sum(1, 2, 3)=6
sum(*values)=60
sum(1, *values, 100)=161
[1, 2, 3, 4]
one, two and three
9
[a, b, c]

说明:

  • 第 33–35 行:一个函数 [greet],其中两个参数有默认值。Java 程序需要三个重载的方法。该函数的函数体返回表达式 [if] 的值;
  • 第 6 行:[greeting] 和 [upperCase] 取默认值 "Hello" 和 [false];
  • 第 7 行:[greeting] 接收“Good evening”,而 [upperCase] 取其默认值;
  • 第 9 行:借助命名参数,我们传递 [upperCase] 而不传递 [greeting],后者保留其默认值。在 Java 中,问候语也必须传递;
  • 第 11 行:所有实参都是命名的,且顺序与声明时的顺序不同;
  • 第 39–43 行:三个 [describe] 函数,它们的参数类型不同。这些是表达式体函数:函数体简化为单个表达式,紧跟在 [=] 符号之后书写,不带花括号或 [return]。返回类型随后由该表达式推断(这里是 [Unit] ,即 [println] 的类型:该函数不返回有用的值);
  • 第 14–16 行:编译器根据实际参数的类型选择函数。字符 ["] 在字符串中写作 [\"] (第 43 行);
  • 第 45–51 行:[sum] 接受任意数量的整数,它们被接收到类型为 [numbers] 的数组 [IntArray] 中;
  • 第 19–24 行:[sum] 分别在不带参数、带三个整数、带由运算符 [*] 展开的数组元素,以及两种形式组合的情况下被调用;
  • 第 26–29 行:许多 Kotlin 函数具有可变数量的参数:[listOf]、[setOf]、[arrayOf]、[format]、[maxOf]……扩展函数 [format] 作用于格式字符串,而不是像 Java 的静态方法 [String] 那样作用于类 [String.format]。Kotlin 没有静态方法:[String.join(" - ", "a", "b", "c")] 在 Kotlin 中不存在(你应该写 [listOf("a", "b", "c").joinToString(" - ")],第 5 章)。由 [setOf] 创建的集合会删除重复的 "a"。

3.11. 局部函数与元组:Kotlin 的解决方案

3.11.1. 局部函数、lambda 与局部类

与 Java 不同,Kotlin 允许你定义局部函数——即写在另一个函数内部、只能在该作用域内使用的函数。这对于拆分较长的函数很有用,同时不会让整个文件充斥着可见的函数。局部函数可以访问包含它的函数的局部变量,并可以修改它们。

在函数内部,你还可以使用:

  • Lambda,即可以存储在变量中的小型匿名函数:[val cube = { x: Int -> x * x * x }]。该变量随后具有函数类型,在这里是 [(Int) -> Int],lambda 的调用方式与函数相同:[cube(3)]。Lambda 将在第 7 章“函数类型、Lambda 与事件”中介绍。与 Java 不同,Kotlin 的 lambda 可以修改其周围的局部变量 [var] ;
  • 局部类,在函数内部声明,只能在函数内部使用。

3.11.2. 二元组、三元组、解构与数据类型

其他语言有元组,它把多个值组合在一起而无需声明类型。Kotlin 没有为它们提供专门的语法,但其标准库提供了两个泛型数据类 [Pair<A, B>] 和 [Triple<A, B, C>],它们的组成部分称为 [first]、[second]、和 [third]。二元组可以用 [Pair(1, "one")] 创建,或者更具可读性地使用中缀函数 [to]:[1 to "one"]。

二元组、三元组以及任何数据类的组成部分,都可以使用解构声明在一条语句中提取出来:[val (number, name) = pair] 声明两个变量,分别用第一个和第二个组成部分初始化。不需要的组成部分用 _ 代替:[val (_, age, _) = triple]。解构也可用于循环,例如 [for] (正如我们在 [withIndex()] 中所见),以及 lambda 的参数中。它基于组成部分的位置 ,而不是它们的名称:[val (name, number) = pair] 会把数字放入 [name]。

要为元组提供具名的组成部分,可以声明一个数据类:[data class Couple(val number: Int, val name: String)]。这等价于 Java 记录,但更灵活(数据类可以有像 [var] 这样的组成部分,可以被解构,等等)。当两个值之间的关系显而易见时,元组便于局部使用;一旦公共函数返回多个值,使用组成部分带有名称的数据类会使代码更易读。

程序 [Basics31.kt] 如下:

// 局部函数、lambda、局部类;Pair、Triple、解构、数据类
package basics31

fun main() {
    // 局部函数:在 main 中声明,只能在其中使用
    fun square(x: Int) = x * x
    println("square(7)=${square(7)}")
    // 存储在变量中的 lambda(第 7 章)
    val cube = { x: Int -> x * x * x }
    println("cube(3)=${cube(3)}")

    // 局部函数或 lambda 可以读取和修改其周围的局部变量
    var counter = 0
    fun increment() {
        counter++
    }
    val increment2 = { counter += 10 }
    increment()
    increment()
    increment2()
    println("counter=$counter")

    // 局部类:在函数中声明,只能在其中使用
    class Accumulator {
        var total = 0
            private set

        fun add(value: Int) {
            total += value
        }
    }
    val acc = Accumulator()
    acc.add(5)
    acc.add(8)
    println("total=${acc.total}")

    // Pair 和 Triple:含两个和三个元素的元组
    val pair = Pair(1, "one")
    val pair2 = 2 to "two"
    println("pair=$pair, pair.first=${pair.first}, pair.second=${pair.second}, pair2=$pair2")
    val triple = Triple("Dupont", 45, true)
    println("triple=$triple, triple.third=${triple.third}")
    // 解构声明:将元组拆分为多个变量
    val (number, name) = pair2
    println("number=$number, name=$name")
    val (_, age, _) = triple
    println("age=$age")
    // for 循环中的解构
    for ((n, label) in listOf(1 to "one", 2 to "two", 3 to "three")) {
        print("$n:$label ")
    }
    println()

    // 数据类:各组成部分带有名称的元组
    data class Couple(val number: Int, val name: String)
    val t1 = Couple(1, "one")
    println("t1=$t1, t1.number=${t1.number}, t1.name=${t1.name}")
    // 类型测试和解构
    val obj: Any = Couple(3, "three")
    if (obj is Couple) {
        val (num, label) = obj
        println("number=$num, name=$label")
    }

    // 返回多个值的函数
    val (quotient, remainder) = divide(17, 5)
    println("17 = 5 * $quotient + $remainder")
    val d = divide(23, 4)
    println("d=$d, d.quotient=${d.quotient}")
    val (min, max) = minMax(intArrayOf(12, -4, 35, 7))
    println("min=$min, max=$max")

    // 用 pair 交换两个变量
    var a = 1
    var b = 2
    val (newA, newB) = b to a
    a = newA
    b = newB
    println("a=$a, b=$b")
}

// 用数据类代替记录
data class IntegerDivision(val quotient: Int, val remainder: Int)

fun divide(a: Int, b: Int) = IntegerDivision(a / b, a % b)

// 当两个值的含义显而易见时,用 pair
fun minMax(values: IntArray): Pair<Int, Int> {
    var min = values[0]
    var max = values[0]
    for (v in values) {
        if (v < min) min = v
        if (v > max) max = v
    }
    return min to max
}

结果:

> gradlew -q run -Pmain=basics31.Basics31Kt
square(7)=49
cube(3)=27
counter=12
total=13
pair=(1, one), pair.first=1, pair.second=one, pair2=(2, two)
triple=(Dupont, 45, true), triple.third=true
number=2, name=two
age=45
1:one 2:two 3:three
t1=Couple(number=1, name=one), t1.number=1, t1.name=one
number=3, name=three
17 = 5 * 3 + 2
d=IntegerDivision(quotient=5, remainder=3), d.quotient=5
min=-4, max=35
a=2, b=1

说明:

  • 第 6 行:一个带表达式体的局部函数,声明在函数 [main] 中,并在第 7 行被调用;
  • 第 9 行:一个 lambda。[{ x: Int -> x * x * x }] 读作“把 x * x * x 与整数 x 关联起来的函数”。变量 [cube] 的类型 [(Int) -> Int] 由编译器推断;
  • 第 10 行:lambda 像函数一样被调用。在 Java 中,你必须知道函数式接口的方法([applyAsInt]);
  • 第 13–21 行:局部函数 [increment] 和 lambda [increment2] 都修改函数 [counter] 的局部变量 [main]:1 + 1 + 10 = 12。在 Java 中,lambda 不能修改局部变量,因此必须使用单元素数组;
  • 第 24–29 行:一个局部类 *[Accumulator]*,带有一个属性 *[total] 和一个方法 *[add]。[private set] 使该属性只能在类内部写入:它可以在 [main] 中读取(第 35 行),但不能被修改。类将在第 4 章介绍;
  • 第 32–34 行:通过调用构造函数创建 [Accumulator] 类型的对象——不使用 [new] 运算符——然后调用它的方法;
  • 第 38–40 行:两个二元组,使用 [Pair] 构造器和 [to] 函数创建。二元组的 [toString()] 方法将其显示在圆括号中;
  • 第 41–42 行:一个由三种不同类型组成的三元组;
  • 第 44 行:二元组 [pair2] 被拆分为两个变量 [number] 和 [name];
  • 第 46 行:只保留三元组的第二个组成部分;
  • 第 49–50 行:在 [for] 循环内部解包列表中的每个二元组;
  • 第 55 行:一个局部数据类;
  • 第 57 行:数据类的 [toString()] 方法显示类名及其组成部分;[number] 和 [name] 属性返回这些组成部分;
  • 第 59–62 行:在 [obj is Couple] 检查之后,[obj] 被视为 [Couple] (智能类型转换),并且可以被解构。Kotlin 没有与 Java 21 的记录模式([obj instanceof Couple(int number, String name)])等价的东西,但类型检查后接解构赋值能产生相同的结果;
  • 第 66–71 行:函数 [divide] 和 [minMax] (第 85–95 行)各返回两个值:第一个放在 [IntegerDivision] 数据类中(第 83 行),第二个以二元组的形式返回。调用者可以对结果进行解构(第 66 行和第 70 行),也可以将其存入变量并使用组成部分的名称(第 68–69 行);
  • lines 74–78: swapping two variables with a pair. Kotlin does not allow assigning to existing variables in a single statement via destructuring ([(a, b) = b to a] is rejected): we destruct into two new variables, which we then assign. The [a = b.also { b = a }] idiom in the [Basics29.kt] program is shorter;
  • 第 92–93 行:一条 [if] 语句,其唯一的动作写在同一行,不带花括号。

在较大的程序中,我们会定义类,它把数据以及操作这些数据的函数组合在一起:这是下一章的主题。