gitbook/朱涛 · Kotlin编程第一课/docs/482603.md

# 加餐二 | 什么是“表达式思维”？

    你好，我是朱涛。

在[开篇词](https://time.geekbang.org/column/article/472129)当中，我曾经说过，学好Kotlin的关键在于**思维的转变**。在上一次[加餐课程](https://time.geekbang.org/column/article/478106)当中，我给你介绍了Kotlin的函数式编程思想，相信你对Kotlin的“函数思维”已经有了一定的体会。那么今天这节课，我们就来聊聊Kotlin的**表达式思维**。

所谓编程思维，其实是一种非常抽象的概念，很多时候是只可意会不可言传的。不过，从某种程度上看，学习编程思维，比学习编程语法还要重要。因为**编程思维决定着我们的代码整体的架构与风格**，而具体的某个语法反而没那么大的影响力。当然，如果对Kotlin的语法没有一个全面的认识，编程思维也只会是空中楼阁。

所以，准确地来说，掌握Kotlin的编程思维，是在掌握了Kotlin语法基础上的一次升华。这就好比是，我们学会了基础的汉字以后开始写作文一样。学了汉字以后，如果不懂得写作的技巧，是写不出优美的文章的。同理，如果学了Kotlin语法，却没有掌握它的编程思维，也是写不出优雅的Kotlin代码的。

好，那么接下来，我们就来看看Kotlin的表达式思维。

## 表达式思维

在正式开始学习表达式思维之前，我们先来看一段简单的Kotlin代码。

```plain
var i = 0
if (data != null) {
    i = data
}

var j = 0
if (data != null) {
    j = data
} else {
    j = getDefault()
    println(j)
}

var k = 0
if (data != null) {
    k = data
} else {
    throw NullPointerException()
}

var x = 0
when (data) {
    is Int -> x = data
    else -> x = 0
}

var y = 0
try {
    y = "Kotlin".toInt()
} catch (e: NumberFormatException) {
    println(e)
    y = 0
}

```

这些代码，如果我们用Java的思维来分析的话，是挑不出太多毛病的。但是站在Kotlin的角度，就完全不一样了。

利用Kotlin的语法，我们完全可以将代码写得更加简洁，就像下面这样：

```plain
val i = data ?: 0
val j = data ?: getDefault().also { println(it) }

val k = data?: throw NullPointerException()



val x = when (data) {
    is Int -> data
    else -> 0
}

val y = try {
    "Kotlin".toInt()
} catch (e: NumberFormatException) {
    println(e)
    0
}

```

这段代码看起来就简洁了不少，但如果你有Java经验，你在写代码的时候，脑子里第一时间想到的一定不是这样的代码模式。这个，也是我们需要格外注意培养表达式思维的原因。

不过，现在你心里可能已经出现了一个疑问：**Kotlin凭什么就能用这样的方式写代码呢？**其实这是因为：if、when、throw、try-catch这些语法，在Kotlin当中都是**表达式**。

那么，这个“表达式”到底是什么呢？其实，与[表达式](https://kotlinlang.org/spec/expressions.html#expressions)（Expression）对应的，还有另一个概念，我们叫做[语句](https://kotlinlang.org/spec/statements.html#statements)（Statement）。这两者的准确定义其实很复杂，你可以点击我这里给出的链接去看看它们之间区别。

不过我们可以先简单来概括一下：**表达式，是一段可以产生值的代码；而语句，则是一句不产生值的代码。**这样解释还是有些抽象，我们来看一些例子：

```plain
val a = 1    // statement
println(a)   // statement

// statement
var i = 0
if (data != null) {
    i = data
}

// 1 + 2 是一个表达式，但是对b的赋值行为是statement
val b = 1 + 2

// if else 整体是一个表达式
// a > b是一个表达式
// a - b是一个表达式
// b - a是一个表达式。
fun minus(a: Int, b: Int) = if (a > b) a - b else b - a

// throw NotImplementedError() 是一个表达式
fun calculate(): Int = throw NotImplementedError()

```

这段代码是描述了常见的Kotlin代码模式，从它的注释当中，我们其实可以总结出这样几个规律：

*   赋值语句，就是典型的statement；
*   if语法，既可以作为语句，也可以作为表达式；
*   语句与表达式，它们可能会出现在同一行代码中，比如val b = 1 + 2；
*   表达式还可能包含“子表达式”，就比如这里的minus方法；
*   throw语句，也可以作为表达式。

但是看到这里，你的心中应该还是有一个疑问没有解开，那就是：**calculate()这个函数难道不会引起编译器报错吗？**

```plain
//       函数返回值类型是Int，实际上却抛出了异常，没有返回Int
//                ↓       ↓
fun calculate(): Int = throw NotImplementedError()

```

确实，在刚开始接触Kotlin的时候，我也无法理解这样的代码。直到我弄清楚Kotlin整个类型系统以后，我才真正找到答案。

所以，为了让你能真正理解Kotlin表达式背后的原理，接下来，我们就来系统学习一下Kotlin的类型系统吧。

## 类型系统

在课程的[第1讲](https://time.geekbang.org/column/article/472154)我们就学过，在Kotlin当中，Any是所有类型的父类，我们可以称之为**根类型**。同时，我们也学过，Kotlin的类型还分为**可空类型**和**不可空类型**。举个例子，对于字符串类型，就有String、String?，它们两者分别代表了不为空的字符串、可能为空的字符串。

在这个基础上，我们很容易就能推测出，Kotlin的类型体系应该是这样的：

![](https://static001.geekbang.org/resource/image/18/40/1873d04968cd8aca90381b9f84651f40.jpg?wh=2000x979)

也就是，Any是所有非空类型的根类型；而Any?是所有可空类型的根类型。那么现在，你可能会想到这样的一个问题：**Any与Any?之间是什么关系呢？**

### Any与Any?与Object

从表面上看，这两个确实没有继承关系。不过，它们之间其实是存在一些微妙的联系的。

在Kotlin当中，我们可以把“子类型”赋值给“父类型”，就像下面的代码一样：

```plain
val s: String = ""
val any: Any = s

```

由于String是Any的子类型，因此，我们可以将String类型赋值给Any类型。而实际上，Any和“Any?”之间也是类似的，我们可以将Any类型赋值给“Any？”类型，反之则不行。

```plain
val a: Any = ""
val b: Any? = a // 通过

val c: Any = b  // 报错

```

类似的，String类型可以赋值给“String？”类型，反之也不行。你可能会想这是为什么呢？  
其实，**任何类型，当它被“?”修饰，变成可空类型以后，它就变成原本类型的父类了。**所以，从某种程度上讲，我们可以认为“Any？”是所有Kotlin类型的**根类型**。它的具体关系如下图所示：

![](https://static001.geekbang.org/resource/image/d9/dd/d904d1ed5df67211058yya5098868cdd.jpg?wh=2000x1044)

因此，我们可以说：虽然Any与Any？之间没有继承的关系，但是我们可以将Any看作是Any？的子类；String类型可以看作是String？的子类。

而由于Any与“Any？”之间并没有明确的继承关系，但它们又存在父子类型的关系，所以在上面的示意图中，我们用虚线来表示。

所以到这里，我们就弄明白了一个问题：**Kotlin的Any与Java的Object之间是什么关系？**

那么，答案也是显而易见的，Java当中的Object类型，对应Kotlin的“Any？”类型。但两者并**不完全等价**，因为Kotlin的Any可以没有wait()、notify()之类的方法。因此，我们只能说Kotlin的“Any？”与Java的Object是大致对应的。Intellij有一个功能，可以将Java代码转换成Kotlin代码，我们可以借此印证。

这是一段Java代码，它有三个方法，分别是可为空的Object类型、不可为空的Object类型，以及无注解的Object类型。

```java
public class TestType {

    @Nullable  // 可空注解
    public Object test() { return null; }

    public Object test1() { return null; }

    @NotNull  // 不可空注解
    public Object test2() { return 1; }
}

```

上面的代码转换成Kotlin以后，会变成这样：

```plain
class TestType {
    fun test(): Any? { return null }

    fun test1(): Any? { return null }

    fun test2(): Any { return 1 }
}

```

由此可见，在没有注解标明可空信息的时候，Object类型是会被当作“Any？”来看待的。而在有了注解修饰以后，Kotlin就能够识别出到底是Any，还是“Any？”。

### Unit与Void与void

在Kotlin当中，除了普通的Any、String的类型之外，还有一个特殊的类型，叫做**Unit**。而Unit这个类型，经常会被拿来和Java的Void、void来对比。

那么在这里，你首先需要知道的是：在Java当中，Void和void不是一回事（注意大小写），前者是一个Java的类，后者是一个用于修饰方法的关键字。如下所示：

```plain
public final class Void {

    public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");

    private Void() {}
}

```

从语法含义上来讲，Kotlin的Unit与Java的void更加接近，但Unit远不止于此。在Kotlin当中，Unit也是一个类，这点跟Void又有点像。比如，在下面的代码中，Unit是一个类型的同时，还是一个单例：

```plain
public object Unit {
    override fun toString() = "kotlin.Unit"
}

```

所以，我们就可以用Unit写出很灵活的代码。就像下面这样：

```plain
fun funUnit(): Unit { }

fun funUnit1(): Unit { return Unit }

```

可以看到，当返回值类型是Unit的时候，我们既可以选择不写return，也可以选择return一个Unit的单例对象。

另外，在使用泛型编程的时候，当T类型作为返回值类型的时候，我们传入Unit以后，就不再需要写return了。

```plain
interface Task<T> {
    fun excute(any: Any): T
}

class PrintTask: Task<Unit> {
    override fun excute(any: Any) {
        println(any)
        // 这里写不写return都可以
    }
}

```

更重要的是，Unit还有助于我们实现函数类型。

```plain
val f: () -> Unit = {}

```

所以，Kotlin的Unit与Java的Void或者void并不存在等价的关系，但它们之间确实存在一些概念上的相似性。至此，我们也可以更新一下前面那个类型系统关系图了：

![](https://static001.geekbang.org/resource/image/74/7f/74e9ea7a804e30bc0e49982ce12f547f.jpg?wh=2000x1036)

可见，Unit其实和String类型一样，就是一个普通的类。只是因为Kotlin编译器会特殊对待它，当Unit作为返回值类型的时候，可以不需要return。

好了，接着，我们再来看看Kotlin当中经常被提到的Nothing类型。

### Nothing

在有了前面的基础以后呢，Nothing就很容易理解了。其实，**Nothing就是Kotlin所有类型的子类型**。

Nothing的概念与“Any?”恰好相反。“Any?”是所有的Kotlin类型的父类，Nothing则是所有类型的子类。如果用一张图来概括，大概会是这样的：

![](https://static001.geekbang.org/resource/image/35/3a/35dd00d1acyyd43b7b72dc4cf84d3c3a.jpg?wh=2000x1125)

事实上，像Nothing这样的概念，在函数式编程当中，也被叫做**底类型**（Bottom Type），因为它位于整个类型体系的最底部。

而了解了Kotlin的Nothing类型以后，我们其实就可以尝试着来解答前面例子中留下来的疑问了：

```plain
//       函数返回值类型是Int，实际上却抛出了异常，没有返回Int
//                ↓       ↓
fun calculate(): Int = throw NotImplementedError() // 不会报错

//       函数返回值类型是Any，实际上却抛出了异常，没有返回Any
//                ↓       ↓
fun calculate1(): Any = throw Exception() // 不会报错

//       函数返回值类型是Unit，实际上却抛出了异常，没有返回Unit
//                 ↓       ↓
fun calculate2(): Unit = throw Exception() // 不会报错

```

根据这段代码可以发现，不管函数的返回值类型是什么，我们都可以使用抛出异常的方式来实现它的功能。这样我们其实就可以推测出一个结论：**throw这个表达式的返回值是Nothing类型。**而既然Nothing是所有类型的子类型，那么它当然是可以赋值给任意其他类型的。

可是，我们如何才能印证这个结论是否正确呢？很简单，我们可以把两个函数的返回值类型都改成Nothing，然后看看编译器会不会报错：

```plain
// 不会报错
fun calculate(): Nothing = throw NotImplementedError() 

// 不会报错
fun calculate1(): Nothing = throw Exception() 

// Nothing构造函数是私有的，因此我们无法构造它的实例
public class Nothing private constructor()

```

可见，编译器仍然不会报错。这也就印证了我们前面的猜测：throw表达式的返回值类型是Nothing。

另外，我们应该也注意到了Nothing类的构造函数是私有的，因此我们无法构造出它的实例。而当Nothing类型作为函数参数的时候，一个有趣的现象就出现了：

```plain
// 这是一个无法调用的函数，因为找不到合适的参数
fun show(msg: Nothing) {
}

show(null) // 报错
show(throw Exception()) // 虽然不报错，但方法仍然不会调用

```

这里我们定义的这个show方法，它的参数类型是Nothing，而由于Nothing的构造函数是私有的，这就导致我们将无法调用show这个函数，除非我们抛出异常，但这没有意义。这个概念在泛型星投影的时候是有应用的，具体你可以点击[这个链接](https://kotlinlang.org/docs/generics.html#star-projections)去查看详情。

而除此之外，Nothing还有助于编译器进行代码流程的推断。比如说，当一个表达式的返回值是Nothing的时候，就往往意味着它后面的语句不再有机会被执行。如下图所示：

![图片](https://static001.geekbang.org/resource/image/33/5a/3365f67ab5f828ef23af65484d317a5a.png?wh=676x371)

在了解了Unit与Nothing这两个不可空的类型以后，我们再来看看它们对应的可空类型。

### Unit?与Nothing?

也许你也注意到了，Unit对应的还有一个“Unit?”类型，那么这个类型有什么意义吗？

我们可以看看下面的代码：

```plain
fun f1(): Unit? { return null } // 通过

fun f2(): Unit? { return Unit } // 通过

fun f3(): Unit? { throw Exception() } // 通过

fun f4(): Unit? { } // 报错，缺少return

```

可见，Kotlin编译器只会把Unit类型当作无需返回值的类型，而Unit?则不行。

所以，Unit?这个类型其实没有什么广泛的应用场景，因为它失去了原本的编译器特权后，就只能有3种实现方式，即null、Unit单例、Nothing。也就是说，当Unit?作为返回值的时候，我们的函数必须要return一个值了，它返回值的类型可以是null、Unit单例、Nothing这三种情况。

好，接下来我们再来看看“Nothing?”这个类型。

```plain
fun calculate1(): Nothing? = null
fun calculate2(): Nothing? = throw Exception()

```

由以上代码示例可知，当Nothing?作为返回值类型的时候，我们可以返回null，或者是抛出异常。这一切都符合预期，而当它作为函数参数的时候，也会有一些有趣的变化。

```plain
//               变化在这里
//                   ↓
fun show(msg: Nothing?) {
}

show(null) // 通过
show(throw Exception()) // 虽然不报错，但方法仍然不会调用

```

可以看到，当参数类型是Nothing?的时候，我们的函数仍然是可以调用的。这其实就能进一步说明一个问题：**Nothing才是底类型，而“Nothing?”则不是底类型。**  
这一点其实在前面的类型关系图中就有体现，现在你就可以真正理解了：

![](https://static001.geekbang.org/resource/image/35/3a/35dd00d1acyyd43b7b72dc4cf84d3c3a.jpg?wh=2000x1125)

到这里相信你也明白了，“Unit?”“Nothing?”这两个类型，其实并没有太多实际的应用场景，不过由于它们是Kotlin类型系统当中特殊的类型，因此我们也应该对它们有个清晰的认识。

这样，在系统学习了Kotlin的类型系统以后，我们对表达式理解就可以更上一层楼了。

## 表达式的本质

我们再来看看表达式的定义：**表达式，是一段可以产生值的代码；而语句，则是一句不产生值的代码。**

也许你听说过这样一句话：在Kotlin当中，一切都是表达式。**注意！这句话其实是错的。**因为Kotlin当中还是存在语句的，比如while循环、for循环，等等。

不过，如果我们换个说法：**在Kotlin当中，大部分代码都是表达式。**这句话就对了。Kotlin的类型系统当中的Unit和Nothing，让很多原本无法产生返回值的语句，变成了表达式。

我们来举个例子：

```plain
// statement
println("Hello World.")

// println("Hello World.") 变成了表达式
val a = println("Hello World.")

// statement
throw Exception()

// throw 变成了表达式
fun test1() = throw Exception() 

```

从上面的代码案例中，我们可以总结出两个规律。

*   由于Kotlin存在Unit这个类型，因此println(“Hello World.”)这行代码也可以变成表达式，它所产生的值就是Unit这个单例。
*   由于Kotlin存在Nothing这个类型，因此throw也可以作为表达式，它所产生的值就是Nothing类型。

注意，因为Java当中不存在Unit、Nothing这样的类型，所以Java里返回值为void的函数是无法成为表达式的，另外，throw这样的语句也是无法成为表达式的。而也正是因为Kotlin这样的类型系统，才让大部分的语句都摇身一变成为了表达式。因为Unit、Nothing在Kotlin编译器看来，也是所有类型当中的一种。

可以说，Unit和Nothing填补了原本Java当中的类型系统，让Kotlin的类型系统更加全面。也正因为如此，Kotlin才可以拥有真正的函数类型，比如：

```plain
val f: (String) -> Unit = ::println

```

可以看到，如果不存在Unit这个类型，我们是无法描述println这个函数的类型的。正因为println函数的返回值类型为Unit，我们才可以用“(String) -> Unit”来描述它。

换句话说就是：**Kotlin的类型系统让大部分的语句都变成了表达式，同时也让无返回值的函数有了类型。**

而所谓的表达式思维，其实就是要求我们开发者在编程的时候，**时刻记住Kotlin大部分的语句都是可以作为表达式的**，并且由于表达式都是有返回值的，这也就让我们可以用一种全新的思维来写代码。这在很多时候，都可以大大简化我们的代码逻辑。

那么现在，我们再回过头看之前的代码，就会觉得很顺眼了：

```plain
val i = data ?: 0
val j = data ?: getDefault().also { println(it) }

val k = data?: throw NullPointerException()


val x = when (data) {
    is Int -> data
    else -> 0
}

val y = try {
    "Kotlin".toInt()
} catch (e: NumberFormatException) {
    0
}

```

## 小结

好，今天这节加餐，到这里就接近尾声了，我们来做个简单的总结。

*   所谓的**表达式思维**，就是要时刻记住：Kotlin大部分的语句都是表达式，它是可以产生返回值的。利用这种思维，往往可以大大简化代码逻辑。
*   Any是所有非空类型的根类型，而“Any?”才是所有类型的**根类型**。
*   Unit与Java的void类型，代表一个函数不需要返回值；而“Unit?”这个类型则没有太多实际的意义。
*   当Nothing作为函数返回值的时候，意味着这个函数永远不会返回结果，而且还会截断程序的后续流程。Kotlin编译器也会根据这一点，进行流程分析。
*   当Nothing作为函数参数的时候，就意味着这个函数永远无法被正常调用。这在泛型星投影的时候是有一定应用的。
*   另外，Nothing可以看作是“Nothing?”子类型，因此，Nothing可以看作是Kotlin所有类型的**底类型**。
*   正是因为Kotlin在类型系统当中，加入了Unit、Nothing这两个类型，才让大部分无法产生值的语句摇身一变，成为了表达式。这也是“Kotlin大部分的语句都是表达式”的根本原因。

## 思考题

这节课，我们学习了表达式思维，请问，你觉得它和我们前面学到的“函数式编程”有联系吗？为什么？欢迎在留言区分享你的答案和思考，也欢迎你把今天的内容分享给更多的朋友。