# 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版本进行下载了。 ![图片](https://static001.geekbang.org/resource/image/04/a7/04cf1b899574ceff2ecd099e41af1fa7.gif?wh=1000x770) 当然，这里我更推荐你可以自己手动从[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里，一切都是对象。** ![](https://static001.geekbang.org/resource/image/yy/3b/yyd95b04616943878351867c4d1e063b.jpg?wh=2000x1077) 实际上，从某种程度上讲，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表达式，强制要求逻辑分支完整，让你写出来的逻辑永远不会有漏洞。 ![图片](https://static001.geekbang.org/resource/image/32/67/32ab3d37cd7f9650f4cba17736305c67.jpg?wh=1920x1983) 这些都是Kotlin的**闪光点**，也是它最珍贵的地方。 这一切，都得益于Kotlin的发明者JetBrains。作为最负盛名的IDE创造者，JetBrains能深刻捕捉到开发者的需求。它知道开发者喜欢什么、讨厌什么，它甚至知道开发者容易犯什么样的错误，从而在语言设计的层面规避错误。站在这个角度看，JetBrains能够创造出炙手可热的Kotlin语言，就一点都不奇怪了。 以上这么多的“闪光点”还仅仅只是局限于我们这节课的内容，如果放眼全局，这样的例子更是数不胜数。**Kotlin对比Java的提升，如果独立去看其中的某一个点，都不足以让一个开发者心动。不过，一旦这样的改善积少成多，Kotlin的优势就会显得尤为明显。**这也是很多程序员表示“Kotlin用过了就回不去”的原因。 ## 思考题 虽然Kotlin在语法层面摒弃了“原始类型”，但有时候为了性能考虑，我们确实需要用“原始类型”。这时候我们应该怎么办？ 欢迎在评论区分享你的思路，这个问题我会在第三节课给出答案，我们下节课再见。