|
|
# 01 | Kotlin基础语法：正式开启学习之旅
|
|
|
|
|
|
你好，我是朱涛。从今天开始，我们就正式踏上Kotlin语言学习与实践的旅途了。这节课，我想先带你来学习下Kotlin的基础语法，包括变量、基础类型、函数和流程控制。这些基础语法是程序最基本的元素。
|
|
|
|
|
|
不过，如果你有使用Java的经验，可能会觉得今天的内容有点多余，毕竟Kotlin和Java的基础语法是比较相似的，它们都是基于JVM的语言。但其实不然，Kotlin作为一门新的语言，它包含了许多新的特性，由此也决定着Kotlin的代码风格。**如果你不够了解Kotlin的这些新特性，你会发现自己只是换了种方式在写Java而已。**
|
|
|
|
|
|
并且，在具备Java语言的知识基础上，这节课的内容也可以帮你快速将已有的经验迁移过来。这样的话，针对相似的语法，你可以直接建立Kotlin与Java的对应关系，进而加深理解。当然，即使你没有其他编程经验也没关系，从头学即可，Kotlin的语法足够简洁，也非常适合作为第一门计算机语言来学习。
|
|
|
|
|
|
在课程中，我会用最通俗易懂的语言，来给你解释Kotlin的基础知识，并且会结合一些Java和Kotlin的代码案例，来帮助你直观地体会两种语言的异同点。而针对新的语法，我也会详细解释它存在的意义，以及都填补了Java的哪些短板，让你可以对Kotlin新语法的使用场景做到心中基本有数。
|
|
|
|
|
|
## 开发环境
|
|
|
|
|
|
在正式开始学习基础语法之前，我们还需要配置一下Kotlin语言的环境，因为直接从代码开始学能给我们带来最直观的体验。
|
|
|
|
|
|
那么要运行Kotlin代码，最快的方式，就是**使用Kotlin官方的**[PlayGround](https://play.kotlinlang.org/)。通过这个在线工具，我们可以非常方便地运行Kotlin代码片段。当然，这种方式用来临时测试一小段代码是没有问题的，但对于复杂的工程就有些力不从心了。
|
|
|
|
|
|
另一种方式，也是**我个人比较推荐的方式，那就是安装**[IntelliJ IDEA](https://www.jetbrains.com/idea/download/)。它是Kotlin官方提供的集成开发工具，也是世界上最好的IDE之一，如果你用过Android Studio，你一定会对它很熟悉，因为Android Studio就是由IntelliJ IDEA改造的。
|
|
|
|
|
|
如果你的电脑没有Java环境，在安装完最新版的IntelliJ IDEA以后，通过“File -> Project Structure -> SDKs”，然后点击“加号按钮”就可以选择第三方提供的OpenJDK 1.8版本进行下载了。
|
|
|
|
|
|
|
|
|
|
|
|
当然，这里我更推荐你可以自己手动从[Oracle官网](https://www.oracle.com/java/technologies/downloads/)下载JDK 1.6、1.7、1.8、11这几个版本，然后再安装、配置Java多版本环境。这在实际工作中也是必备的。
|
|
|
|
|
|
需要注意的是，IntelliJ IDEA分为Ultimate付费版和Community免费版，对于我们的Kotlin学习来说，免费版完全够用。
|
|
|
|
|
|
这样，在配置好了开发环境之后，我们就可以试着一边敲代码，一边体会、思考和学习Kotlin语言中这些最基础的语法知识了。那么下面我们就来看下，在Kotlin语言中是如何定义变量的吧。
|
|
|
|
|
|
## 变量
|
|
|
|
|
|
在Java/C当中，如果我们要声明变量，我们必须要声明它的类型，后面跟着变量的名称和对应的值，然后以分号结尾。就像这样：
|
|
|
|
|
|
```java
|
|
|
Integer price = 100;
|
|
|
|
|
|
```
|
|
|
|
|
|
而Kotlin则不一样，我们要使用“**val**”或者是“**var**”这样的关键字作为开头，后面跟“变量名称”，接着是“变量类型”和“赋值语句”，最后是分号结尾。就像这样：
|
|
|
|
|
|
```plain
|
|
|
/*
|
|
|
关键字 变量类型
|
|
|
↓ ↓ */
|
|
|
var price: Int = 100; /*
|
|
|
↑ ↑
|
|
|
变量名 变量值 */
|
|
|
|
|
|
```
|
|
|
|
|
|
不过，像Java那样每写一行代码就写一个分号，其实也挺麻烦的。所以为了省事，在Kotlin里面，我们一般会把代码末尾的分号省略，就像这样：
|
|
|
|
|
|
```plain
|
|
|
var price: Int = 100
|
|
|
|
|
|
```
|
|
|
|
|
|
另外，由于Kotlin支持**类型推导**，大部分情况下，我们的变量类型可以省略不写，就像这样：
|
|
|
|
|
|
```plain
|
|
|
var price = 100 // 默认推导类型为： Int
|
|
|
|
|
|
```
|
|
|
|
|
|
还有一点我们要注意，就是在Kotlin当中，我们应该尽可能避免使用var，**尽可能多地去使用val**。
|
|
|
|
|
|
```plain
|
|
|
var price = 100
|
|
|
price = 101
|
|
|
|
|
|
val i = 0
|
|
|
i = 1 // 编译器报错
|
|
|
|
|
|
```
|
|
|
|
|
|
原因其实很简单：
|
|
|
|
|
|
* val声明的变量，我们叫做**不可变变量**，它的值在初始化以后就无法再次被修改，它相当于Java里面的final变量。
|
|
|
* var声明的变量，我们叫做**可变变量**，它对应Java里的普通变量。
|
|
|
|
|
|
## 基础类型
|
|
|
|
|
|
了解了变量类型如何声明之后，我们再来看下Kotlin中的基础类型。
|
|
|
|
|
|
基础类型，包括我们常见的数字类型、布尔类型、字符类型，以及前面这些类型组成的数组。这些类型是我们经常会遇到的概念，因此我们把它统一归为“基础类型”。
|
|
|
|
|
|
### 一切都是对象
|
|
|
|
|
|
在Java里面，基础类型分为原始类型（Primitive Types）和包装类型（Wrapper Type）。比如，整型会有对应的int和Integer，前者是原始类型，后者是包装类型。
|
|
|
|
|
|
```java
|
|
|
int i = 0; // 原始类型
|
|
|
Integer j = 1; // 包装类型
|
|
|
|
|
|
```
|
|
|
|
|
|
Java之所以要这样做，是因为原始类型的开销小、性能高，但它不是对象，无法很好地融入到面向对象的系统中。而包装类型的开销大、性能相对较差，但它是对象，可以很好地发挥面向对象的特性。在 [JDK源码](https://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/lang/Integer.java)当中，我们可以看到Integer作为包装类型，它是有成员变量以及成员方法的，这就是它作为对象的优势。
|
|
|
|
|
|
然而，在Kotlin语言体系当中，是没有原始类型这个概念的。这也就意味着，**在Kotlin里，一切都是对象。**
|
|
|
|
|
|
|
|
|
|
|
|
实际上，从某种程度上讲，Java的类型系统并不是完全面向对象的，因为它存在原始类型，而原始类型并不属于对象。而Kotlin则不一样，它从语言设计的层面上就规避了这个问题，类型系统则是完全面向对象的。
|
|
|
|
|
|
我们看一段代码，来更直观地感受Kotlin的独特之处：
|
|
|
|
|
|
```plain
|
|
|
val i: Double = 1.toDouble()
|
|
|
|
|
|
```
|
|
|
|
|
|
可以发现，由于在Kotlin中，整型数字“1”被看作是对象了，所以我们可以调用它的成员方法toDouble()，而这样的代码在Java中是无法实现的。
|
|
|
|
|
|
### 空安全
|
|
|
|
|
|
既然Kotlin中的一切都是对象，那么对象就有可能为空。也许你会想到写这样的代码：
|
|
|
|
|
|
```plain
|
|
|
val i: Double = null // 编译器报错
|
|
|
|
|
|
```
|
|
|
|
|
|
可事实上，以上的代码并不能通过Kotlin编译。这是因为Kotlin强制要求开发者**在定义变量的时候，指定这个变量是否可能为null**。对于可能为null的变量，我们需要在声明的时候，在变量类型后面加一个问号“?”：
|
|
|
|
|
|
```plain
|
|
|
val i: Double = null // 编译器报错
|
|
|
val j: Double? = null // 编译通过
|
|
|
|
|
|
```
|
|
|
|
|
|
并且由于Kotlin对可能为空的变量类型做了强制区分，这就意味着，“可能为空的变量”无法直接赋值给“不可为空的变量”，当然，反向赋值是没有问题的。
|
|
|
|
|
|
```plain
|
|
|
var i: Double = 1.0
|
|
|
var j: Double? = null
|
|
|
|
|
|
i = j // 编译器报错
|
|
|
j = i // 编译通过
|
|
|
|
|
|
```
|
|
|
|
|
|
Kotlin这么设计的原因也很简单，如果我们将“可能为空的变量”直接赋值给了“不可为空的变量”，这会跟它自身的定义产生冲突。而如果我们实在有这样的需求，也不难实现，只要做个判断即可：
|
|
|
|
|
|
```plain
|
|
|
var i: Double = 1.0
|
|
|
val j: Double? = null
|
|
|
|
|
|
if (j != null) {
|
|
|
i = j // 编译通过
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
好，在了解了Kotlin和Java这两种语言的主要区别后，下面就让我们来全面认识下Kotlin的基础类型。
|
|
|
|
|
|
### 数字类型
|
|
|
|
|
|
首先，在数字类型上，Kotlin和Java几乎是一致的，包括它们对数字“字面量”的定义方式。
|
|
|
|
|
|
```plain
|
|
|
val int = 1
|
|
|
val long = 1234567L
|
|
|
val double = 13.14
|
|
|
val float = 13.14F
|
|
|
val hexadecimal = 0xAF
|
|
|
val binary = 0b01010101
|
|
|
|
|
|
```
|
|
|
|
|
|
这里我也来给你具体介绍下：
|
|
|
|
|
|
* 整数默认会被推导为“Int”类型；
|
|
|
* Long类型，我们则需要使用“L”后缀；
|
|
|
* 小数默认会被推导为“Double”，我们不需要使用“D”后缀；
|
|
|
* Float类型，我们需要使用“F”后缀；
|
|
|
* 使用“0x”，来代表十六进制字面量；
|
|
|
* 使用“0b”，来代表二进制字面量。
|
|
|
|
|
|
但是，对于数字类型的转换，Kotlin与Java的转换行为是不一样的。**Java可以隐式转换数字类型，而Kotlin更推崇显式转换。**
|
|
|
|
|
|
举个简单的例子，在Java和C当中，我们经常直接把int类型赋值给long类型，编译器会自动为我们做类型转换，如下所示：
|
|
|
|
|
|
```java
|
|
|
int i = 100;
|
|
|
long j = i;
|
|
|
|
|
|
```
|
|
|
|
|
|
这段代码按照Java的编程思维方式来看，的确好像是OK的。但是你要注意，虽然Java编译器不会报错，可它仍然可能会带来问题，因为它们本质上不是一个类型，int、long、float、double这些类型之间的互相转换是存在精度问题的。尤其是当这样的代码掺杂在复杂的逻辑中时，在碰到一些边界条件的情况下，即使出现了Bug也不容易排查出来。
|
|
|
|
|
|
所以，同样的代码，在Kotlin当中是行不通的：
|
|
|
|
|
|
```plain
|
|
|
val i = 100
|
|
|
val j: Long = i // 编译器报错
|
|
|
|
|
|
```
|
|
|
|
|
|
在Kotlin里，这样的隐式转换被抛弃了。正确的做法应该是显式调用Int类型的toLong()函数：
|
|
|
|
|
|
```plain
|
|
|
val i = 100
|
|
|
val j: Long = i.toLong() // 编译通过
|
|
|
|
|
|
```
|
|
|
|
|
|
其实，如果我们仔细翻看Kotlin的源代码，会发现更多类似的函数，比如toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toChar()等等。Kotlin这样设计的优势也是显而易见的，**我们代码的可读性更强了，将来也更容易维护了**。
|
|
|
|
|
|
### 布尔类型
|
|
|
|
|
|
然后我们再来了解下Kotlin中布尔类型的变量，它只有两种值，分别是**true****和****false**。布尔类型支持一些逻辑操作，比如说：
|
|
|
|
|
|
* “&”代表“与运算”；
|
|
|
* “|”代表“或运算”；
|
|
|
* “!”代表“非运算”；
|
|
|
* “&&”和“||”分别代表它们对应的“短路逻辑运算”。
|
|
|
|
|
|
```plain
|
|
|
val i = 1
|
|
|
val j = 2
|
|
|
val k = 3
|
|
|
|
|
|
val isTrue: Boolean = i < j && j < k
|
|
|
|
|
|
```
|
|
|
|
|
|
### 字符：Char
|
|
|
|
|
|
Char用于代表单个的字符，比如`'A'`、`'B'`、`'C'`，字符应该用单引号括起来。
|
|
|
|
|
|
```plain
|
|
|
val c: Char = 'A'
|
|
|
|
|
|
```
|
|
|
|
|
|
如果你有Java或C的使用经验，也许会写出这样的代码：
|
|
|
|
|
|
```plain
|
|
|
val c: Char = 'A'
|
|
|
val i: Int = c // 编译器报错
|
|
|
|
|
|
```
|
|
|
|
|
|
这个问题其实跟前面Java的数字类型隐式转换的问题类似，所以针对这种情况，我们应该调用对应的函数来做类型转换。这一点我们一定要牢记在心。
|
|
|
|
|
|
```plain
|
|
|
val c: Char = 'A'
|
|
|
val i: Int = c.toInt() // 编译通过
|
|
|
|
|
|
```
|
|
|
|
|
|
### 字符串：String
|
|
|
|
|
|
字符串（String），顾名思义，就是一连串的字符。和Java一样，Kotlin中的字符串也是不可变的。在大部分情况下，我们会使用双引号来表示字符串的字面量，这一点跟Java也是一样的。
|
|
|
|
|
|
```plain
|
|
|
val s = "Hello Kotlin!"
|
|
|
|
|
|
```
|
|
|
|
|
|
不过与此同时，Kotlin还为我们提供了非常简洁的**字符串模板**：
|
|
|
|
|
|
```plain
|
|
|
val name = "Kotlin"
|
|
|
print("Hello $name!")
|
|
|
/* ↑
|
|
|
直接在字符串中访问变量
|
|
|
*/
|
|
|
// 输出结果：
|
|
|
Hello Kotlin!
|
|
|
|
|
|
```
|
|
|
|
|
|
这样的特性，在Java当中是没有的，这是Kotlin提供的新特性。虽然说这个字符串模板功能，我们用Java也同样可以实现，但它远没有Kotlin这么简洁。在Java当中，我们必须使用两个“+”进行拼接，比如说`("Hello" + name + "!")`。这样一来，在字符串格式更复杂的情况下，代码就会很臃肿。
|
|
|
|
|
|
当然，如果我们需要在字符串当中引用更加复杂的变量，则需要使用花括号将变量括起来：
|
|
|
|
|
|
```plain
|
|
|
val array = arrayOf("Java", "Kotlin")
|
|
|
print("Hello ${array.get(1)}!")
|
|
|
/* ↑
|
|
|
复杂的变量，使用${}
|
|
|
*/
|
|
|
// 输出结果：
|
|
|
Hello Kotlin!
|
|
|
|
|
|
```
|
|
|
|
|
|
另外，Kotlin还新增了一个**原始字符串**，是用三个引号来表示的。它可以用于存放复杂的多行文本，并且它定义的时候是什么格式，最终打印也会是对应的格式。所以当我们需要复杂文本的时候，就不需要像Java那样写一堆的加号和换行符了。
|
|
|
|
|
|
```plain
|
|
|
val s = """
|
|
|
当我们的字符串有复杂的格式时
|
|
|
原始字符串非常的方便
|
|
|
因为它可以做到所见即所得。 """
|
|
|
|
|
|
print(s)
|
|
|
|
|
|
```
|
|
|
|
|
|
### 数组
|
|
|
|
|
|
最后，我们再来看看Kotlin中数组的一些改变。
|
|
|
|
|
|
在Kotlin当中，我们一般会使用**arrayOf()**来创建数组，括号当中可以用于传递数组元素进行初始化，同时，Kotlin编译器也会根据传入的参数进行类型推导。
|
|
|
|
|
|
```plain
|
|
|
val arrayInt = arrayOf(1, 2, 3)
|
|
|
val arrayString = arrayOf("apple", "pear")
|
|
|
|
|
|
```
|
|
|
|
|
|
比如说，针对这里的arrayInt，由于我们赋值的时候传入了整数，所以它的类型会被推导为整型数组；对于arrayString，它的类型会被推导为字符串数组。
|
|
|
|
|
|
而你应该也知道，在Java当中，数组和其他集合的操作是不一样的。举个例子，如果要获取数组的长度，Java中应该使用“array.length”；但如果是获取List的大小，那么Java中则应该使用“list.size”。这主要是因为数组不属于Java集合。
|
|
|
|
|
|
不过，Kotlin在这个问题的处理上并不一样。**虽然Kotlin的数组仍然不属于集合，但它的一些操作是跟集合统一的。**
|
|
|
|
|
|
```plain
|
|
|
val array = arrayOf("apple", "pear")
|
|
|
println("Size is ${array.size}")
|
|
|
println("First element is ${array[0]}")
|
|
|
|
|
|
// 输出结果：
|
|
|
Size is 2
|
|
|
First element is apple
|
|
|
|
|
|
```
|
|
|
|
|
|
就比如说，以上代码中，我们直接使用array.size就能拿到数组的长度。
|
|
|
|
|
|
## 函数声明
|
|
|
|
|
|
好，了解了Kotlin中变量和基础类型的相关概念之后，我们再来看看它的函数是如何定义的。
|
|
|
|
|
|
在Kotlin当中，函数的声明与Java不太一样，让我们看一段简单的Kotlin代码：
|
|
|
|
|
|
```plain
|
|
|
/*
|
|
|
关键字 函数名 参数类型 返回值类型
|
|
|
↓ ↓ ↓ ↓ */
|
|
|
fun helloFunction(name: String): String {
|
|
|
return "Hello $name !"
|
|
|
}/* ↑
|
|
|
花括号内为：函数体
|
|
|
*/
|
|
|
|
|
|
```
|
|
|
|
|
|
可以看到，在这段代码中：
|
|
|
|
|
|
* 使用了**fun关键字**来定义函数；
|
|
|
* **函数名称**，使用的是[驼峰命名法](https://zh.wikipedia.org/zh/%E9%A7%9D%E5%B3%B0%E5%BC%8F%E5%A4%A7%E5%B0%8F%E5%AF%AB)（大部分情况下）；
|
|
|
* **函数参数**，是以(name: String)这样的形式传递的，这代表了参数类型为String类型；
|
|
|
* **返回值类型**，紧跟在参数的后面；
|
|
|
* 最后是**花括号内的函数体**，它代表了整个函数的逻辑。
|
|
|
|
|
|
另外你可以再注意一个地方，前面代码中的helloFunction函数，它的函数体实际上只有一行代码。那么针对这种情况，我们其实就可以省略函数体的花括号，直接使用“=”来连接，将其变成一种类似变量赋值的函数形式：
|
|
|
|
|
|
```plain
|
|
|
fun helloFunction(name: String): String = "Hello $name !"
|
|
|
|
|
|
```
|
|
|
|
|
|
这种写法，我们称之为**单一表达式函数**。需要注意的是，在这种情况下，表达式当中的“return”是需要去掉的。
|
|
|
|
|
|
另外，由于Kotlin支持类型推导，我们在使用单一表达式形式的时候，返回值的类型也可以省略：
|
|
|
|
|
|
```plain
|
|
|
fun helloFunction(name: String) = "Hello $name !"
|
|
|
|
|
|
```
|
|
|
|
|
|
看到这里，你一定能体会到Kotlin的魅力。它的语法非常得简洁，并且是符合人类的阅读直觉的，我们读这样的代码，就跟读自然语言一样轻松。
|
|
|
|
|
|
然而，Kotlin的优势不仅仅体现在函数声明上，在函数调用的地方，它也有很多独到之处。
|
|
|
|
|
|
### 函数调用
|
|
|
|
|
|
以我们前面定义的函数为例子，如果我们想要调用它，代码的风格和Java基本一致：
|
|
|
|
|
|
```plain
|
|
|
helloFunction("Kotlin")
|
|
|
|
|
|
```
|
|
|
|
|
|
不过，Kotlin提供了一些新的特性，那就是**命名参数**。简单理解，就是它允许我们在调用函数的时候传入“形参的名字”。
|
|
|
|
|
|
```plain
|
|
|
helloFunction(name = "Kotlin")
|
|
|
|
|
|
```
|
|
|
|
|
|
让我们看一个更具体的使用场景：
|
|
|
|
|
|
```plain
|
|
|
fun createUser(
|
|
|
name: String,
|
|
|
age: Int,
|
|
|
gender: Int,
|
|
|
friendCount: Int,
|
|
|
feedCount: Int,
|
|
|
likeCount: Long,
|
|
|
commentCount: Int
|
|
|
) {
|
|
|
//..
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
这是一个包含了很多参数的函数，在Kotlin当中，针对参数较多的函数，我们一般会**以纵向的方式排列**，这样的代码更符合我们从上到下的阅读习惯，省去从左往右翻的麻烦。
|
|
|
|
|
|
但是，如果我们像Java那样调用createUser，代码就会非常难以阅读：
|
|
|
|
|
|
```plain
|
|
|
createUser("Tom", 30, 1, 78, 2093, 10937, 3285)
|
|
|
|
|
|
```
|
|
|
|
|
|
这里代码中的第一个参数，我们知道肯定是name，但是到了后面那一堆的数字，就会让人迷惑了。这样的代码不仅难懂，同时还不好维护。
|
|
|
|
|
|
但如果我们这样写呢？
|
|
|
|
|
|
```plain
|
|
|
createUser(
|
|
|
name = "Tom",
|
|
|
age = 30,
|
|
|
gender = 1,
|
|
|
friendCount = 78,
|
|
|
feedCount = 2093,
|
|
|
likeCount = 10937,
|
|
|
commentCount = 3285
|
|
|
)
|
|
|
|
|
|
```
|
|
|
|
|
|
可以看到，在这段代码中，我们把函数的形参加了进来，形参和实参用“=”连接，建立了两者的对应关系。对比前面Java风格的写法，这样的代码可读性更强了。如果将来你想修改likeCount这个参数，也可以轻松做到。这其实就体现出了Kotlin命名参数的**可读性**与**易维护性**两个优势。
|
|
|
|
|
|
而除了命名参数这个特性，Kotlin还支持**参数默认值**，这个特性在参数较多的情况下同样有很大的优势：
|
|
|
|
|
|
```plain
|
|
|
fun createUser(
|
|
|
name: String,
|
|
|
age: Int,
|
|
|
gender: Int = 1,
|
|
|
friendCount: Int = 0,
|
|
|
feedCount: Int = 0,
|
|
|
likeCount: Long = 0L,
|
|
|
commentCount: Int = 0
|
|
|
) {
|
|
|
//..
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
我们可以看到，gender、friendCount、feedCount、likeCount、commentCount这几个参数都被赋予了默认值。这样做的好处就在于，我们在调用的时候可以省很多事情。比如说，下面这段代码就只需要传3个参数，剩余的4个参数没有传，但是Kotlin编译器会自动帮我们填上默认值。
|
|
|
|
|
|
```plain
|
|
|
createUser(
|
|
|
name = "Tom",
|
|
|
age = 30,
|
|
|
commentCount = 3285
|
|
|
)
|
|
|
|
|
|
```
|
|
|
|
|
|
对于无默认值的参数，编译器会强制要求我们在调用处传参；对于有默认值的参数，则可传可不传。Kotlin这样的特性，在一些场景下就可以极大地提升我们的开发效率。
|
|
|
|
|
|
而如果是在Java当中要实现类似的事情，我们就必须手动定义“3个参数的createUser函数”，或者是使用Builder设计模式。
|
|
|
|
|
|
## 流程控制
|
|
|
|
|
|
在Kotlin当中，流程控制主要有if、when、for、 while，这些语句可以控制代码的执行流程。它们也是体现代码逻辑的关键。下面我们就来一一学习下。
|
|
|
|
|
|
### if
|
|
|
|
|
|
if语句，在程序当中主要是用于逻辑判断。Kotlin当中的if与Java当中的基本一致：
|
|
|
|
|
|
```plain
|
|
|
val i = 1
|
|
|
if (i > 0) {
|
|
|
print("Big")
|
|
|
} else {
|
|
|
print("Small")
|
|
|
}
|
|
|
|
|
|
输出结果：
|
|
|
Big
|
|
|
|
|
|
```
|
|
|
|
|
|
可以看到，由于i大于0，所以程序会输出“Big”，这很好理解。不过Kotlin的if，并不是程序语句（Statement）那么简单，它还可以作为**表达式**（Expression）来使用。
|
|
|
|
|
|
```plain
|
|
|
val i = 1
|
|
|
val message = if (i > 0) "Big" else "Small"
|
|
|
|
|
|
print(message)
|
|
|
|
|
|
输出结果：
|
|
|
Big
|
|
|
|
|
|
```
|
|
|
|
|
|
以上的代码其实跟之前的代码差不多，它们做的是同一件事。不同的是，我们把if当作表达式在用，将if判断的结果，赋值给了一个变量。同时，Kotlin编译会根据if表达式的结果自动推导出变量“message”的类型为“String”。这种方式就使得Kotlin的代码更加简洁。
|
|
|
|
|
|
而类似的逻辑，如果要用Java来实现的话，我们就必须先在if外面定义一个变量message，然后分别在两个分支内对message赋值：
|
|
|
|
|
|
```java
|
|
|
int i = 1
|
|
|
String message = ""
|
|
|
if (i > 0) {
|
|
|
message = "Big"
|
|
|
} else {
|
|
|
message = "Small"
|
|
|
}
|
|
|
|
|
|
print(message)
|
|
|
|
|
|
```
|
|
|
|
|
|
这样两相对比下，我们会发现Java的实现方式明显丑陋一些：**不仅代码行数更多，逻辑也松散了**。
|
|
|
|
|
|
另外，由于Kotlin当中明确规定了类型分为“可空类型”“不可空类型”，因此，我们会经常遇到可空的变量，并且要判断它们是否为空。我们直接来看个例子：
|
|
|
|
|
|
```plain
|
|
|
fun getLength(text: String?): Int {
|
|
|
return if (text != null) text.length else 0
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
在这个例子当中，我们把if当作表达式，如果text不为空，我们就算出它的长度；如果它为空，长度就取0。
|
|
|
|
|
|
但是，如果你实际使用Kotlin写过代码，你会发现：在Kotlin中，类似这样的判断逻辑出现得非常频繁，如果每次都要写一个完整的if else分支，其实也很麻烦。
|
|
|
|
|
|
为此，Kotlin针对这种情况就提供了一种简写，叫做**Elvis表达式**。
|
|
|
|
|
|
```plain
|
|
|
fun getLength(text: String?): Int {
|
|
|
return text?.length ?: 0
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
可以看到，通过Elvis表达式，我们就再也不必写“`if (xxx != null) xxx else xxx`”这样的赋值代码了。它在提高代码可读性的同时，还能提高我们的编码效率。
|
|
|
|
|
|
### when
|
|
|
|
|
|
when语句，在程序当中主要也是用于逻辑判断的。当我们的代码逻辑只有两个分支的时候，我们一般会使用if/else，而在大于两个逻辑分支的情况下，我们使用when。
|
|
|
|
|
|
```plain
|
|
|
val i: Int = 1
|
|
|
|
|
|
when(i) {
|
|
|
1 -> print("一")
|
|
|
2 -> print("二")
|
|
|
else -> print("i 不是一也不是二")
|
|
|
}
|
|
|
|
|
|
输出结果：
|
|
|
一
|
|
|
|
|
|
```
|
|
|
|
|
|
when语句有点像Java里的switch case语句，不过Kotlin的when更加强大，它同时也可以**作为表达式，为变量赋值**，如下所示：
|
|
|
|
|
|
```plain
|
|
|
val i: Int = 1
|
|
|
|
|
|
val message = when(i) {
|
|
|
1 -> "一"
|
|
|
2 -> "二"
|
|
|
else -> "i 不是一也不是二" // 如果去掉这行，会报错
|
|
|
}
|
|
|
|
|
|
print(message)
|
|
|
|
|
|
```
|
|
|
|
|
|
另外，与switch不一样的是，when表达式要求它里面的逻辑分支必须是完整的。举个例子，以上的代码，如果去掉else分支，编译器将报错，原因是：i的值不仅仅只有1和2，这两个分支并没有覆盖所有的情况，所以会报错。
|
|
|
|
|
|
### 循环迭代：while与for
|
|
|
|
|
|
首先while循环，我们一般是用于重复执行某些代码，它在使用上和Java也没有什么区别：
|
|
|
|
|
|
```plain
|
|
|
var i = 0
|
|
|
while (i <= 2) {
|
|
|
println(i)
|
|
|
i++
|
|
|
}
|
|
|
|
|
|
var j = 0
|
|
|
do {
|
|
|
println(j)
|
|
|
j++
|
|
|
} while (j <= 2)
|
|
|
|
|
|
输出结果：
|
|
|
0
|
|
|
1
|
|
|
2
|
|
|
0
|
|
|
1
|
|
|
2
|
|
|
|
|
|
```
|
|
|
|
|
|
但是对于for语句，Kotlin和Java的用法就明显不一样了。
|
|
|
|
|
|
在Java当中，for也会经常被用于循环，经常被用来替代while。不过，**Kotlin的for语句更多的是用于“迭代”。**比如，以下代码就代表了迭代array这个数组里的所有元素，程序会依次打印出：“1、2、3”。
|
|
|
|
|
|
```plain
|
|
|
val array = arrayOf(1, 2, 3)
|
|
|
for (i in array) {
|
|
|
println(i)
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
而除了迭代数组和集合以外，Kotlin还支持迭代一个“区间”。
|
|
|
|
|
|
首先，要定义一个区间，我们可以使用“`..`”来连接数值区间的两端，比如“`1..3`”就代表从1到3的闭区间，左闭右闭：
|
|
|
|
|
|
```plain
|
|
|
val oneToThree = 1..3 // 代表 [1, 3]
|
|
|
|
|
|
```
|
|
|
|
|
|
接着，我们就可以使用for语句，来对这个闭区间范围进行迭代：
|
|
|
|
|
|
```plain
|
|
|
for (i in oneToThree) {
|
|
|
println(i)
|
|
|
}
|
|
|
|
|
|
输出结果：
|
|
|
1
|
|
|
2
|
|
|
3
|
|
|
|
|
|
```
|
|
|
|
|
|
甚至，我们还可以**逆序迭代**一个区间，比如：
|
|
|
|
|
|
```plain
|
|
|
for (i in 6 downTo 0 step 2) {
|
|
|
println(i)
|
|
|
}
|
|
|
|
|
|
输出结果：
|
|
|
6
|
|
|
4
|
|
|
2
|
|
|
0
|
|
|
|
|
|
```
|
|
|
|
|
|
以上代码的含义就是逆序迭代一个区间，从6到0，每次迭代的步长是2，这意味着6迭代过后，到4、2，最后到0。**需要特别注意的是**，逆序区间我们不能使用“`6..0`”来定义，如果用这样的方式来定义的话，代码将无法正常运行。
|
|
|
|
|
|
好了，那么到目前为止，Kotlin的变量、基础类型、函数、流程控制，我们就都已经介绍完了。掌握好这些知识点，我们就已经可以写出简单的程序了。当然，我们的Kotlin学习之路才刚刚开始，在下节课，我会带你来学习Kotlin面向对象相关的知识点。
|
|
|
|
|
|
## 小结
|
|
|
|
|
|
学完了这节课，现在我们知道虽然Kotlin和Java的语法很像，但在一些细节之处，Kotlin总会有一些新的东西。如果你仔细琢磨这些不同点，你会发现它正是大部分程序员所需要的。举个例子，作为开发者，我们都讨厌写冗余的代码，喜欢简洁易懂的代码。那么在今天学完了基础语法之后，我们可以来看看Kotlin在这方面都做了哪些改进：
|
|
|
|
|
|
* 支持类型推导；
|
|
|
* 代码末尾不需要分号；
|
|
|
* 字符串模板；
|
|
|
* 原始字符串，支持复杂文本格式；
|
|
|
* 单一表达式函数，简洁且符合直觉；
|
|
|
* 函数参数支持默认值，替代Builder模式的同时，可读性还很强；
|
|
|
* if和when可以作为表达式。
|
|
|
|
|
|
同时，JetBrains也非常清楚开发者在什么情况下容易出错，所以，它在语言层面也做了很多改进：
|
|
|
|
|
|
* 强制区分“可为空变量类型”和“不可为空变量类型”，规避空指针异常；
|
|
|
* 推崇不可变性（val），对于没有修改需求的变量，IDE会智能提示开发者将“var”改为“val”；
|
|
|
* 基础类型不支持隐式类型转换，这能避免很多隐藏的问题；
|
|
|
* 数组访问行为与集合统一，不会出现array.length、list.size这种恼人的情况；
|
|
|
* 函数调用支持命名参数，提高可读性，在后续维护代码的时候不易出错；
|
|
|
* when表达式，强制要求逻辑分支完整，让你写出来的逻辑永远不会有漏洞。
|
|
|
|
|
|
|
|
|
|
|
|
这些都是Kotlin的**闪光点**，也是它最珍贵的地方。
|
|
|
|
|
|
这一切，都得益于Kotlin的发明者JetBrains。作为最负盛名的IDE创造者，JetBrains能深刻捕捉到开发者的需求。它知道开发者喜欢什么、讨厌什么，它甚至知道开发者容易犯什么样的错误，从而在语言设计的层面规避错误。站在这个角度看，JetBrains能够创造出炙手可热的Kotlin语言，就一点都不奇怪了。
|
|
|
|
|
|
以上这么多的“闪光点”还仅仅只是局限于我们这节课的内容，如果放眼全局，这样的例子更是数不胜数。**Kotlin对比Java的提升，如果独立去看其中的某一个点，都不足以让一个开发者心动。不过，一旦这样的改善积少成多，Kotlin的优势就会显得尤为明显。**这也是很多程序员表示“Kotlin用过了就回不去”的原因。
|
|
|
|
|
|
## 思考题
|
|
|
|
|
|
虽然Kotlin在语法层面摒弃了“原始类型”，但有时候为了性能考虑，我们确实需要用“原始类型”。这时候我们应该怎么办？
|
|
|
|
|
|
欢迎在评论区分享你的思路，这个问题我会在第三节课给出答案，我们下节课再见。
|
|
|
|