关于kotlin:快速入门-kotlin-编程第一行代码-Kotlin-学习笔记

不同于面向过程的语言（比方 C 语言），面向对象的语言是能够创立类的。类就是对事物的一种封装。

简略概括一下，就是将事物封装成具体的类，而后将事物所领有的属性和能力别离定义成类中的字段和函数，接下来对类进行实例化，再依据具体的编程需要调用类中的字段和办法即可。

class Person {
    var name = ""
    var age = 0
    
    fun eat() {println(name + "is eating. He is" + age + "years old.")
    }
}

val p = Person()

Kotlin 中也是应用 class 关键字来申明一个类的
应用 var 关键字创立了 name 和 age 这两个字段，这是因为咱们须要在创建对象之后再指定具体的姓名和年龄，而如果应用 val 关键字的话，初始化之后就不能再从新赋值了
Kotlin 中实例化一个类的形式和 Java 是根本相似的，只是去掉了 new 关键字而已

能够让 Student 类去继承 Person 类，这样 Student 就主动领有了 Person 中的字段和函数，另外还能够定义本人独有的字段和函数。想要让 Student 类继承 Person 类，咱们得做两件事才行

在 Person 类的后面加上 open 关键字使其能够被继承
在 Java 中继承的关键字是 extends，而在 Kotlin 中变成了一个冒号
```
class Student : Person() {
  var sno = ""
  var grade = 0
}
```

继承这里最麻烦的就是 为什么 Person 类的前面要加上一对括号呢？Java 中继承的时候并不需要括号。要晓得为什么，咱们要先来看一下 Kotlin 中构造函数的一些常识。

任何一个面向对象的编程语言都会有构造函数的概念，Kotlin 中也有，然而 Kotlin 将构造函数分成了两种：主构造函数和次构造函数。

主构造函数将会是你最罕用的构造函数，每个类默认都会有一个不带参数的主构造函数，当然你也能够显式地给它指明参数。主构造函数的特点是没有函数体，间接定义在类名的前面即可。比方上面这种写法：

class Student(val sno: String, val grade: Int) : Person() {}

到这里为止都还挺好了解的吧？然而这和那对括号又有什么关系呢？这就波及了 Java 继承个性中的一个规定，子类中的构造函数必须调用父类中的构造函数，这个规定在 Kotlin 中也要恪守。

那么回头看一下 Student 类，当初咱们申明了一个主构造函数，依据继承个性的规定，子类的构造函数必须调用父类的构造函数，可是主构造函数并没有函数体，咱们怎么去调用父类的构造函数呢？你可能会说，在 init 构造体中去调用不就好了。这或者是一种方法，但相对不是一种好方法，因为在绝大多数的场景下，咱们是不须要编写 init 构造体的。

Kotlin 当然没有采纳这种设计，而是用了另外一种简略然而可能不太好了解的设计形式：括号。子类的主结构函数调用父类中的哪个构造函数，在继承的时候通过括号来指定。因而再来看一遍这段代码，你应该就能了解了吧。

class Student(val sno: String, val grade: Int) : Person() {}

在这里，Person 类前面的一对空括号示意 Student 类的主构造函数在初始化的时候会调用 Person 类的无参数构造函数，即便在无参数的状况下，这对括号也不能省略。

而如果咱们将 Person 革新一下，将姓名和年龄都放到主构造函数当中，如下所示：

open class Person(val name: String, val age: Int) {...}

此时你的 Student 类肯定会报错，这里呈现谬误的起因也很显著，Person 类前面的空括号示意要去调用 Person 类中无参的构造函数，然而 Person 类当初曾经没有无参的构造函数了，所以就提醒了上述谬误。

如果咱们想解决这个谬误的话，就必须给 Person 类的构造函数传入 name 和 age 字段，可是 Student 类中也没有这两个字段呀。很简略，没有就加呗。咱们能够在 Student 类的主构造函数中加上 name 和 age 这两个参数，再将这两个参数传给 Person 类的构造函数，代码如下所示：

class Student(val sno: String, val grade: Int, name: String, age: Int) Person(name, age) {...}

学到这里，咱们就将 Kotlin 的主构造函数根本把握了，是不是感觉继承时的这对括号问题也不是那么难以了解？然而，Kotlin 在括号这个问题上的复杂度并不仅限于此，因为咱们还没波及 Kotlin 构造函数中的另一个组成部分——次构造函数。

其实你简直是用不到次构造函数的，Kotlin 提供了一个给函数设定参数默认值的性能，基本上能够代替次构造函数的作用，咱们会在本章最初学习这部分内容。然而思考到知识结构的完整性，我决定还是介绍一下次构造函数的相干常识，顺便探讨一下括号问题在次构造函数上的区别。

你要晓得，任何一个类只能有一个主构造函数，然而能够有多个次构造函数。次构造函数也能够用于实例化一个类，这一点和主构造函数没有什么不同，只不过它是有函数体的。

Kotlin 规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数（包含间接调用）。这里我通过一个具体的例子就能简略说明，代码如下：

class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {constructor(name: String, age: Int) : this("001", 1, name, age)

    constructor() : this("geely", 24)

}

次构造函数是通过 constructor 关键字来定义的，这里咱们定义了两个次构造函数：第一个次构造函数接管 name 和 age 参数，而后它又通过 this 关键字调用了主构造函数，并将 sno 和 grade 这两个参数赋值成初始值；第二个次构造函数不接管任何参数，它通过 this 关键字调用了咱们方才定义的第一个次构造函数，并将 name 和 age 参数也赋值成初始值，因为第二个次构造函数间接调用了主构造函数，因而这依然是非法的。

那么当初咱们就领有了 3 种形式来对 Student 类进行实体化，别离是通过不带参数的构造函数、通过带两个参数的构造函数和通过带 4 个参数的构造函数，对应代码如下所示：

val student1 = Student()
val student2 = Student("Jack", 19)
val student3 = Student("a123", 5, "Jack", 19)

这样咱们就将次构造函数的用法把握得差不多了，然而到目前为止，继承时的括号问题还没有进一步延长，临时和之前学过的场景是一样的。

那么接下来咱们就再来看一种十分非凡的状况：类中只有次构造函数，没有主构造函数。这种状况真的非常少见，但在 Kotlin 中是容许的。当一个类没有显式地定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。咱们联合代码来看一下：

class Student : Person {constructor(name: String, age: Int) : super(name, age) {}}

留神这里的代码变动，首先 Student 类的前面没有显式地定义主构造函数，同时又因为定义了次构造函数，所以当初 Student 类是没有主构造函数的。那么既然没有主构造函数，继承 Person 类的时候也就不须要再加上括号了。其实起因就是这么简略，只是很多人在刚开始学习 Kotlin 的时候没能了解这对括号的意义和规定，因而总感觉继承的写法有时候要加上括号，有时候又不要加，搞得昏头昏脑的，而在你真正了解了规定之后，就会发现其实还是很好懂的。

另外，因为没有主构造函数，次构造函数只能间接调用父类的构造函数，上述代码也是将 this 关键字换成了 super 关键字，这部分就很好了解了，因为和 Java 比拟像，我也就不再多说了。

这一大节咱们对 Kotlin 的继承和构造函数的问题探索得比拟深，同时这也是很多人新上手 Kotlin 时比拟难了解的局部，心愿你能好好把握这部分内容。

Java 中继承应用的关键字是 extends，实现接口应用的关键字是 implements，而 Kotlin 中对立应用冒号，两头用逗号进行分隔。另外接口的前面不必加上括号，因为它没有构造函数能够去调用，咱们来看下代码：

class Student(name: String, age: Int) : Person(name, age), Study {override fun readBooks() {println(name + "is reading.")
    }
    override fun doHomework() {println(name + "is doing homework.")
    }
}

data class Cellphone(val brand: String, val price: Double)

利用 Kotlin 创立数据类非常简单，只须要一行代码就能够了，你没看错，只须要一行代码就能够实现了！神奇的中央就在于 data 这个关键字，当在一个类后面申明了 data 关键字时，就表明你心愿这个类是一个数据类，Kotlin 会依据主构造函数中的参数帮你将 equals()、hashCode()、toString() 等固定且无理论逻辑意义的办法主动生成，从而大大减少了开发的工作量。

在 Kotlin 中创立一个单例类的形式极其简略，只须要将 class 关键字改成 object 关键字即可。

object Singleton {fun singletonTest() {println("singletonTest is called.")
    }
}

能够看到，在 Kotlin 中咱们不须要私有化构造函数，也不须要提供 getInstance() 这样的静态方法，只须要把 class 关键字改成 object 关键字，一个单例类就创立实现了。而调用单例类中的函数也很简略，比拟相似于 Java 中静态方法的调用形式：

Singleton.singletonTest()

这种写法尽管看上去像是静态方法的调用，但其实 Kotlin 在背地主动帮咱们创立了一个 Singleton 类的实例，并且保障全局只会存在一个 Singleton 实例。

Kotlin 从第一个版本开始就反对了 Lambda 编程，并且 Kotlin 中的 Lambda 性能极为弱小，我甚至认为 Lambda 才是 Kotlin 的灵魂所在。

不过，本章只是 Kotlin 的入门章节，我不可能在这短短一节里就将 Lambda 的方方面面全副笼罩。因而，这一节咱们只学习一些 Lambda 编程的基础知识，而像高阶函数、DSL 等高级 Lambda 技巧，咱们会在本书的后续章节缓缓学习。

汇合的函数式 API 是用来入门 Lambda 编程的绝佳示例，不过在此之前，咱们得先学习创立汇合的形式才行。

Kotlin 专门提供了一个内置的 listOf() 函数来简化初始化汇合的写法，如下所示：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")

for-in 循环不仅能够用来遍历区间，还能够用来遍历汇合。当初咱们就尝试一下应用 for-in 循环来遍历这个水果汇合，在 main() 函数中编写如下代码：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    for (fruit in list) {println(fruit)
    }
}

Map 是一种键值对模式的数据结构，因而在用法上和 List、Set 汇合有较大的不同。

Kotlin 中并不倡议应用 put() 和 get() 办法来对 Map 进行增加和读取数据操作，而是更加举荐应用一种相似于数组下标的语法结构，比方向 Map 中增加一条数据就能够这么写：

map["Apple"] = 1

而从 Map 中读取一条数据就能够这么写：

val number = map["Apple"]

当然，这依然不是最简便的写法，因为 Kotlin 毫无疑问地提供了一对 mapOf() 和 mutableMapOf() 函数来持续简化 Map 的用法。在 mapOf() 函数中，咱们能够间接传入初始化的键值对组合来实现对 Map 汇合的创立：

val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)

汇合的函数式 API 有很多个，这里我并不打算带你涉猎所有函数式 API 的用法，而是重点学习函数式 API 的语法结构，也就是 Lambda 表达式的语法结构。

首先咱们来思考一个需要，如何在一个水果汇合外面找到单词最长的那个水果？当然这个需要很简略，也有很多种写法，你可能会很天然地写出如下代码：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
var maxLengthFruit = ""
for (fruit in list) {if (fruit.length > maxLengthFruit.length) {maxLengthFruit = fruit}
}
println("max length fruit is $maxLengthFruit")

这段代码很简洁，思路也很清晰，能够说是一段相当不错的代码了。然而如果咱们应用汇合的函数式 API，就能够让这个性能变得更加容易：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengthFruit = list.maxBy{it.length}
prinln("max length fruit is $maxLengthFruit")

上述代码应用的就是函数式 API 的用法，只用一行代码就能找到汇合中单词最长的那个水果。或者你当初了解这段代码还比拟吃力，那是因为咱们还没有开始学习 Lambda 表达式的语法结构，等学完之后再来从新看这段代码时，你就会感觉非常简单易懂了。

首先来看一下 Lambda 的定义，如果用最直白的语言来论述的话，Lambda 就是一小段能够作为参数传递的代码。从定义上看，这个性能就很厉害了，因为失常状况下，咱们向某个函数传参时只能传入变量，而借助 Lambda 却容许传入一小段代码。这里两次应用了“一小段代码”这种形容，那么到底多少代码才算一小段代码呢？Kotlin 对此并没有进行限度，然而通常不倡议在 Lambda 表达式中编写太长的代码，否则可能会影响代码的可读性。

接着咱们来看一下 Lambda 表达式的语法结构：

{参数名 1: 参数类型, 参数名 2: 参数类型 -> 函数体}

这是 Lambda 表达式最残缺的语法结构定义。首先最外层是一对大括号，如果有参数传入到 Lambda 表达式中的话，咱们还须要申明参数列表，参数列表的结尾应用一个 -> 符号，示意参数列表的完结以及函数体的开始，函数体中能够编写任意行代码（尽管不倡议编写太长的代码），并且最初一行代码会主动作为 Lambda 表达式的返回值。

当然，在很多状况下，咱们并不需要应用 Lambda 表达式残缺的语法结构，而是有很多种简化的写法。那么接下来咱们就由繁入简开始吧。

还是回到方才找出最长单词水果的需要，后面应用的函数式 API 的语法结构看上去如同很非凡，但其实 maxBy 就是一个一般的函数而已，只不过它接管的是一个 Lambda 类型的参数，并且会在遍历汇合时将每次遍历的值作为参数传递给 Lambda 表达式。maxBy 函数的工作原理是依据咱们传入的条件来遍历汇合，从而找到该条件下的最大值，比如说想要找到单词最长的水果，那么条件天然就应该是单词的长度了。

了解了 maxBy 函数的工作原理之后，咱们就能够开始套用方才学习的 Lambda 表达式的语法结构，并将它传入到 maxBy 函数中了，如下所示：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val lambda = {fruit: String -> fruit.length}
val maxLengthFruit = list.maxBy(lambda)

能够看到，maxBy 函数本质上就是接管了一个 Lambda 参数而已，并且这个 Lambda 参数是齐全依照方才学习的表达式的语法结构来定义的，因而这段代码应该算是比拟好懂的。

这种写法尽管能够失常工作，然而比拟啰嗦，可简化的点也十分多，上面咱们就开始对这段代码一步步进行简化。

首先，咱们不须要专门定义一个 lambda 变量，而是能够间接将 lambda 表达式传入 maxBy 函数当中，因而第一步简化如下所示：
```
val maxLengthFruit = list.maxBy({fruit: String -> fruit.length})
```
而后 Kotlin 规定，当 Lambda 参数是函数的最初一个参数时，能够将 Lambda 表达式移到函数括号的里面，如下所示：
```
val maxLengthFruit = list.maxBy() { fruit: String -> fruit.length}
```
接下来，如果 Lambda 参数是函数的惟一一个参数的话，还能够将函数的括号省略：
```
val maxLengthFruit = list.maxBy{fruit: String -> fruit.length}
```
这样代码看起来就变得清新多了吧？然而咱们还能够持续进行简化。因为 Kotlin 领有杰出的类型推导机制，Lambda 表达式中的参数列表其实在大多数状况下不用申明参数类型，因而代码能够进一步简化成：
```
val maxLengthFruit = list.maxBy{fruit -> fruit.length}
```
最初，当 Lambda 表达式的参数列表中只有一个参数时，也不用申明参数名，而是能够应用 it 关键字来代替，那么代码就变成了：
```
val maxLengthFruit = list.maxBy {it.length}
```
怎么样？通过一步步推导的形式，咱们就失去了和一开始那段函数式 API 截然不同的写法，是不是当初了解起来就十分轻松了呢？

接下来咱们就再来学习几个汇合中比拟罕用的函数式 API，置信这些对于当初的你来说，应该是没有什么艰难的。

汇合中的 map 函数是最罕用的一种函数式 API，它用于将汇合中的每个元素都映射成一个另外的值，映射的规定在 Lambda 表达式中指定，最终生成一个新的汇合。比方，这里咱们心愿让所有的水果名都变成大写模式，就能够这样写：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.map {it.toUpperCase() }
    for (fruit in newList) {println(fruit)
    }
}

map 函数的性能十分弱小，它能够依照咱们的需要对汇合中的元素进行任意的映射转换，下面只是一个简略的示例而已。除此之外，你还能够将水果名全副转换成小写，或者是只取单词的首字母，甚至是转换成单词长度这样一个数字汇合，只有在 Lambda 示意式中编写你须要的逻辑即可。

接下来咱们再来学习另外一个比拟罕用的函数式 API——filter 函数。顾名思义，filter 函数是用来过滤汇合中的数据的，它能够独自应用，也能够配合方才的 map 函数一起应用。

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.filter {it.length <= 5}
        .map {it.toUpperCase() }
    for (fruit in newList) {println(fruit)
    }
}

接下来咱们持续学习两个比拟罕用的函数式 API——any 和 all 函数。其中 any 函数用于判断汇合中是否至多存在一个元素满足指定条件，all 函数用于判断汇合中是否所有元素都满足指定条件。因为这两个函数都很好了解，咱们就间接通过代码示例学习了：

fun main() {val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val anyResult = list.any {it.length <= 5}
    val allResult = list.all {it.length <= 5}
    println("anyResult is" + anyResult + ", allResult is" + allResult)
}

这样咱们就将 Lambda 表达式的语法结构和几个罕用的函数式 API 的用法都学习完了，尽管汇合中还有许多其余函数式 API，然而只有把握了根本的语法规定，其余函数式 API 的用法只有看一看文档就能把握了，置信这对你来说并不是难事。

Android 零碎上解体率最高的异样类型就是空指针异样（NullPointerException）。置信不只是 Android，其余零碎上也面临着雷同的问题。若要剖析其根本原因的话，我感觉次要是因为空指针是一种不受编程语言查看的运行时异样，只能由程序员被动通过逻辑判断来防止，但即便是最出色的程序员，也不可能将所有潜在的空指针异样全副思考到。

咱们来看一段非常简单的 Java 代码：

public void doStudy(Study study) {study.readBooks();
    study.doHomework();}

这是咱们后面编写过的一个 doStudy() 办法，我将它翻译成了 Java 版。这段代码没有任何简单的逻辑，只是接管了一个 Study 参数，并且调用了参数的 readBooks() 和 doHomework() 办法。

这段代码平安吗？不肯定，因为这要取决于调用方传入的参数是什么，如果咱们向 doStudy() 办法传入了一个 null 参数，那么毫无疑问这里就会产生空指针异样。因而，更加稳当的做法是在调用参数的办法之前先进行一个判空解决，如下所示：

public void doStudy(Study study) {if (study != null) {study.readBooks();
        study.doHomework();}
}

这样就能保障不论传入的参数是什么，这段代码始终都是平安的。

由此能够看出，即便是如此简略的一小段代码，都有产生空指针异样的潜在危险，那么在一个大型项目中，想要齐全躲避空指针异样简直是不可能的事件，这也是它高居各类解体排行榜首位的起因。

然而，Kotlin 却十分迷信地解决了这个问题，它利用编译时判空查看的机制简直杜绝了空指针异样。尽管编译时判空查看的机制有时候会导致代码变得比拟难写，然而不必放心，Kotlin 提供了一系列的辅助工具，让咱们能轻松地解决各种判空状况。上面咱们就逐渐开始学习吧。

还是回到方才的 doStudy() 函数，当初将这个函数再翻译回 Kotlin 版本，代码如下所示：

fun doStudy(study: Study) {study.readBooks()
    study.doHomework()}

这段代码看上去和方才的 Java 版本并没有什么区别，但实际上它是没有空指针危险的，因为 Kotlin 默认所有的参数和变量都不可为空，所以这里传入的 Study 参数也肯定不会为空，咱们能够释怀地调用它的任何函数。如果你尝试向 doStudy() 函数传入一个 null 参数，则会提醒如下图所示的谬误。

看到这里，你可能产生了微小的纳闷，所有的参数和变量都不可为空？这可真是前所未闻的事件，那如果咱们的业务逻辑就是须要某个参数或者变量为空该怎么办呢？不必放心，Kotlin 提供了另外一套可为空的类型零碎，只不过在应用可为空的类型零碎时，咱们须要在编译期间就将所有潜在的空指针异样都解决掉，否则代码将无奈编译通过。

那么可为空的类型零碎是什么样的呢？很简略，就是在类名的前面加上一个问号。比方，Int 示意不可为空的整型，而 Int? 就示意可为空的整型；String 示意不可为空的字符串，而 String? 就示意可为空的字符串。

回到方才的 doStudy() 函数，如果咱们心愿传入的参数能够为空，那么就应该将参数的类型由 Study 改成 Study?，如下图所示。

能够看到，当初在调用 doStudy() 函数时传入 null 参数，就不会再提醒谬误了。然而你会发现，在 doStudy() 函数中调用参数的 readBooks() 和 doHomework() 办法时，却呈现了一个红色下滑线的谬误提醒，这又是为什么呢？

其实起因也很显著，因为咱们将参数改成了可为空的 Study? 类型，此时调用参数的 readBooks() 和 doHomework() 办法都可能造成空指针异样，因而 Kotlin 在这种状况下不容许编译通过。

那么该如何解决呢？很简略，只有把空指针异样都解决掉就能够了，比方做个判断解决，如下
所示：

fun doStudy(study: Study?) {if (study != null) {study.readBooks()
        study.doHomework()}
}

当初代码就能够失常编译通过了，并且还能保障齐全不会呈现空指针异样。

其实学到这里，咱们就曾经根本把握了 Kotlin 的可空类型零碎以及空指针查看的机制，然而为了在编译期间就解决掉所有的空指针异样，通常须要编写很多额定的查看代码才行。如果每处查看代码都应用 if 判断语句，则会让代码变得比拟啰嗦，而且 if 判断语句还解决不了全局变量的判空问题。为此，Kotlin 专门提供了一系列的辅助工具，使开发者可能更轻松地进行判空解决，上面咱们就来一一学习一下。

首先学习最罕用的 ?. 操作符。这个操作符的作用十分好了解，就是当对象不为空时失常调用相应的办法，当对象为空时则什么都不做。比方以下的判空解决代码：

if (a != null) {a.doSomething()
}

这段代码应用 ?. 操作符就能够简化成：

a?.doSomething()

理解了 ?. 操作符的作用，上面咱们来看一下如何应用这个操作符对 doStudy() 函数进行优化，代码如下所示：

fun doStudy(study: Study?) {study?.readBooks()
    study?.doHomework()}

上面咱们再来学习另外一个十分罕用的 ?: 操作符。这个操作符的左右两边都接管一个表达式，如果右边表达式的后果不为空就返回右边表达式的后果，否则就返回左边表达式的后果。察看如下代码：

val c = if (a ! = null) {a} else {b}

这段代码的逻辑应用 ?: 操作符就能够简化成：

val c = a ?: b

接下来咱们通过一个具体的例子来联合应用 ?. 和 ?: 这两个操作符，从而让你加深对它们的了解。

比方当初咱们要编写一个函数用来取得一段文本的长度，应用传统的写法就能够这样写：

fun getTextLength(text: String?): Int {if (text != null) {return text.length}
    return 0
}

因为文本是可能为空的，因而咱们须要先进行一次判空操作，如果文本不为空就返回它的长度，如果文本为空就返回 0。

这段代码看上去也并不简单，然而咱们却能够借助操作符让它变得更加简略，如下所示：

fun getTextLength(text: String?) = text?.length ?: 0

这里咱们将 ?. 和 ?: 操作符联合到了一起应用，首先因为 text 是可能为空的，因而咱们在调用它的 length 字段时须要应用 ?. 操作符，而当 text 为空时，text?.length 会返回一个 null 值，这个时候咱们再借助 ?: 操作符让它返回 0。怎么样，是不是感觉这些操作符越来越好用了呢？

不过 Kotlin 的空指针查看机制也并非总是那么智能，有的时候咱们可能从逻辑上曾经将空指针异样解决了，然而 Kotlin 的编译器并不知道，这个时候它还是会编译失败。

察看如下的代码示例：

var content: String? = "hello"

fun main() {if (content != null) {printUpperCase()
    }
}

fun printUpperCase() {val upperCase = content.toUpperCase()
    println(upperCase)
}

这里咱们定义了一个可为空的全局变量 content，而后在 main() 函数里先进行一次判空操作，当 content 不为空的时候才会调用 printUpperCase() 函数，在 printUpperCase() 函数里，咱们将 content 转换为大写模式，最初打印进去。

看上去如同逻辑没什么问题，然而很遗憾，这段代码肯定是无奈运行的。因为 printUpperCase() 函数并不知道内部曾经对 content 变量进行了非空查看，在调用 toUpperCase() 办法时，还认为这里存在空指针危险，从而无奈编译通过。

在这种状况下，如果咱们想要强行通过编译，能够应用非空断言工具，写法是在对象的前面加上 !!，如下所示：

fun printUpperCase() {val upperCase = content!!.toUpperCase()
    println(upperCase)
}

这是一种有危险的写法，意在通知 Kotlin，我十分确信这里的对象不会为空，所以不必你来帮我做空指针查看了，如果呈现问题，你能够间接抛出空指针异样，结果由我本人承当。

最初咱们再来学习一个比拟不同凡响的辅助工具 ——let。let 既不是操作符，也不是什么关键字，而是一个函数。这个函数提供了函数式 API 的编程接口，并将原始调用对象作为参数传递到 Lambda 表达式中。示例代码如下：

obj.let { obj2 ->
    // 编写具体的业务逻辑
}

能够看到，这里调用了 obj 对象的 let 函数，而后 Lambda 表达式中的代码就会立刻执行，并且这个 obj 对象自身还会作为参数传递到 Lambda 表达式中。不过，为了避免变量重名，这里我将参数名改成了 obj2，但实际上它们是同一个对象，这就是 let 函数的作用。

let 函数属于 Kotlin 中的规范函数，在下一章中咱们将会学习更多 Kotlin 规范函数的用法。

你可能就要问了，这个 let 函数和空指针查看有什么关系呢？其实 let 函数的个性配合 ?. 操作符能够在空指针查看的时候起到很大的作用。

咱们回到 doStudy() 函数当中，目前的代码如下所示：

fun doStudy(study: Study?) {study?.readBooks()
    study?.doHomework()}

尽管这段代码咱们通过 ?. 操作符优化之后能够失常编译通过，但其实这种表达方式是有点啰嗦的，如果将这段代码精确翻译成应用 if 判断语句的写法，对应的代码如下：

fun doStudy(study: Study?) {if (study != null) {study.readBooks()
    }
    
    if (study != null) {study.doHomework()
    }
}

也就是说，原本咱们进行一次 if 判断就能随便调用 study 对象的任何办法，但受制于 ?. 操作符的限度，当初变成了每次调用 study 对象的办法时都要进行一次 if 判断。

这个时候就能够联合应用 ?. 操作符和 let 函数来对代码进行优化了，如下所示：

fun doStudy(study: Study?) {
    study?.let { stu ->
        stu.readBooks()
        stu.doHomework()}
}

我来简略解释一下上述代码，?. 操作符示意对象为空时什么都不做，对象不为空时就调用 let 函数，而 let 函数会将 study 对象自身作为参数传递到 Lambda 表达式中，此时的 study 对象必定不为空了，咱们就能释怀地调用它的任意办法了。

另外还记得 Lambda 表达式的语法个性吗？当 Lambda 表达式的参数列表中只有一个参数时，能够不必申明参数名，间接应用 it 关键字来代替即可，那么代码就能够进一步简化成：

fun doStudy(study: Study?) {
    study?.let {it.readBooks()
        it.doHomework()}
}

在完结本大节内容之前，我还得再讲一点，let 函数是能够解决全局变量的判空问题的，而 if 判断语句则无奈做到这一点。比方咱们将 doStudy() 函数中的参数变成一个全局变量，应用 let 函数依然能够失常工作，但应用 if 判断语句则会提醒谬误，如下图所示。

之所以这里会报错，是因为全局变量的值随时都有可能被其余线程所批改，即便做了判空解决，依然无奈保障 if 语句中的 study 变量没有空指针危险。从这一点上也能体现出 let 函数的劣势。

好了，最罕用的 Kotlin 空指针查看辅助工具大略就是这些了，只有能将本节的内容把握好，你就能够写出更加强壮、简直杜绝空指针异样的代码了。

首先来看一下 Kotlin 中字符串内嵌表达式的语法规定：

"hello, ${obj.name}. nice to meet you!"

能够看到，Kotlin 容许咱们在字符串里嵌入 ${} 这种语法结构的表达式，并在运行时应用表达式执行的后果代替这一部分内容。

上述代码中有一个主构造函数和两个次构造函数，次构造函数在这里的作用是提供了应用更少参数来对 Student 类进行实例化的形式。无参的次构造函数会调用两个参数的次构造函数，并将这两个参数赋值成初始值。两个参数的次构造函数会调用 4 个参数的主构造函数，并将缺失的两个参数也赋值成初始值。这种写法在 Kotlin 中其实是不必要的，因为咱们齐全能够通过只编写一个主构造函数，而后给参数设定默认值的形式来实现，代码如下所示：

class Student(val sno: String = "", val grade: Int = 0, name: String ="", age: Int = 0) : Person(name, age) {}

关于kotlin:快速入门-kotlin-编程第一行代码-Kotlin-学习笔记

疾速入门 Kotlin 编程

面向对象编程

类与对象

继承与构造函数

接口

数据类与单例类

Lambda 编程

汇合的创立与遍历

汇合的函数式 API

空指针查看

可空类型零碎

判空辅助工具

Kotlin 中的小魔术

字符串模板

函数的参数默认值

Just My Socks（注册教程内含优惠码）

关于kotlin:快速入门-kotlin-编程第一行代码-Kotlin-学习笔记

疾速入门 Kotlin 编程

面向对象编程

类与对象

继承与构造函数

接口

数据类与单例类

Lambda 编程

汇合的创立与遍历

汇合的函数式 API

空指针查看

可空类型零碎

判空辅助工具

Kotlin 中的小魔术

字符串模板

函数的参数默认值

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）