Learn Kotlin in 12 Minutes - 2022.srt

1
00:00:00,640 --> 00:00:02,399
在这个视频中我将教会你 Kotlin 编程语言的基础
in this video i'll teach you the core of 

2
00:00:02,399 --> 00:00:04,240
在这个视频中我将教会你 Kotlin 编程语言的基础
the Kotlin programming language

3
00:00:04,240 --> 00:00:06,000
Kotlin 是一种这几年很流行的通用的静态类型语言
Kotlin is a general purpose statically

4
00:00:06,000 --> 00:00:07,759
Kotlin 是一种这几年很流行的通用的静态类型语言
typed language that has become extremely

5
00:00:07,759 --> 00:00:09,840
Kotlin 是一种这几年很流行的通用的静态类型语言
popular in the last few years

6
00:00:09,840 --> 00:00:11,679
Kotlin 既可以用在客户端上
Kotlin can be used on both the client

7
00:00:11,679 --> 00:00:13,519
也可以用在服务端上，这意味着用 Kotlin 写的代码
and the server which means the code can

8
00:00:13,519 --> 00:00:15,280
既可以运行在用户的设备（客户端）上
be run either on the user's device

9
00:00:15,280 --> 00:00:17,119
也可以运行在云服务器（服务端）上用以回应客户端的请求
the client or on some computer in the

10
00:00:17,119 --> 00:00:18,800
也可以运行在云服务器（服务端）上用以回应客户端的请求
cloud called the server

11
00:00:18,800 --> 00:00:20,640
也可以运行在云服务器（服务端）上用以回应客户端的请求
which responds to requests from the

12
00:00:20,640 --> 00:00:21,920
也可以运行在云服务器（服务端）上用以回应客户端的请求
client

13
00:00:21,920 --> 00:00:24,400
在客户端方面，Kotlin 现在被广泛应用于安卓开发
on the client Kotlin is now widely used

14
00:00:24,400 --> 00:00:25,519
在客户端方面，Kotlin 现在被广泛应用于安卓开发
for Android development

15
00:00:25,519 --> 00:00:27,680
——为 25 亿台运行安卓操作系统的设备编写应用程序
to write apps for the 2.5 billion

16
00:00:27,680 --> 00:00:29,679
——为 25 亿台运行安卓操作系统的设备编写应用程序
devices running the Android operating

17
00:00:29,679 --> 00:00:30,720
——为 25 亿运行安卓操作系统的设备编写应用程序
system

18
00:00:30,720 --> 00:00:32,960
近几年 Kotlin 的人气大增
Kotlin has seen a huge rise in

19
00:00:32,960 --> 00:00:33,920
近几年 Kotlin 的人气大增
popularity

20
00:00:33,920 --> 00:00:35,440
我能向你保证未来的几年中它只会变得更受欢迎
and i can promise you it will only

21
00:00:35,440 --> 00:00:38,879
我能向你保证未来的几年中它只会变得更受欢迎
become more popular in the years to come

22
00:00:38,879 --> 00:00:40,399
Kotlin 是一种编程语言，是我们与计算机交流的一种方式
Kotlin is an example of a programming

23
00:00:40,399 --> 00:00:42,320
Kotlin 是一种编程语言，是我们与计算机交流的一种方式
language which is a way for me and you

24
00:00:42,320 --> 00:00:44,239
Kotlin 是一种编程语言，是我们与计算机交流的一种方式
to communicate with computers

25
00:00:44,239 --> 00:00:45,920
归根结底，计算机只能理解二进制的数字——也就是 0 和 1
at the end of the day computers only

26
00:00:45,920 --> 00:00:48,480
归根结底，计算机只能理解二进制的数字——也就是 0 和 1
understand binary zeros and ones

27
00:00:48,480 --> 00:00:50,559
所以这些年我们创造了很多种
so over the years we've created many

28
00:00:50,559 --> 00:00:52,640
不同的方法来告诉计算机
different ways to instruct the computer

29
00:00:52,640 --> 00:00:54,719
我们希望它做什么，每一种方法
what we'd like it to do each of these

30
00:00:54,719 --> 00:00:56,239
都被称为一种编程语言
approaches is called a programming

31
00:00:56,239 --> 00:00:57,039
都被称为一种编程语言
language

32
00:00:57,039 --> 00:00:58,399
你可能已经听说过他们中的一些
and you've probably heard of some of them

33
00:00:58,399 --> 00:01:01,920
例如 C 语言、Java 和 JavaScript
such as C or Java or JavaScript

34
00:01:01,920 --> 00:01:03,440
由于 Kotlin 诞生得更晚，它从早期的编程语言中汲取了教训
since Kotlin was created much more recently

35
00:01:03,440 --> 00:01:05,519
由于 Kotlin 诞生得更晚，它从早期的编程语言中汲取了教训
it has taken the lessons from

36
00:01:05,519 --> 00:01:06,640
由于 Kotlin 诞生得更晚，它从早期的编程语言中汲取了教训
the earlier languages

37
00:01:06,640 --> 00:01:08,560
因此它不仅功能更强大，也更易用
to make something that is both powerful

38
00:01:08,560 --> 00:01:10,400
因此它不仅功能更强大，也更易用
and easy to use

39
00:01:10,400 --> 00:01:11,760
Java 和 Kotlin 有一层特殊的关系——它们彼此之间互相兼容
Java and Kotlin have a special

40
00:01:11,760 --> 00:01:13,680
Java 和 Kotlin 有一层特殊的关系——它们彼此之间互相兼容
relationship since they're compatible

41
00:01:13,680 --> 00:01:14,720
Java 和 Kotlin 有一层特殊的关系——它们彼此之间互相兼容
with each other

42
00:01:14,720 --> 00:01:16,560
如果 Java 是今天被设计的，它就会长得像 Kotlin 那样
Kotlin is what Java would look like if

43
00:01:16,560 --> 00:01:18,320
如果 Java 是今天被设计的，它就会长得像 Kotlin 那样
it was designed today

44
00:01:18,320 --> 00:01:19,840
在这个教程中我会使用名叫 IntelliJ IDEA 的集成开发环境（IDE）来编写 Kotlin 代码
to write Kotlin code i'm going to be

45
00:01:19,840 --> 00:01:21,680
在这个教程中我会使用名叫 IntelliJ IDEA 的集成开发环境（IDE）来编写 Kotlin 代码
using a program called intelliJ which

46
00:01:21,680 --> 00:01:22,880
你可以在互联网上免费下载它（jetbrains.com/idea/download）
you can download for free from the

47
00:01:22,880 --> 00:01:23,840
你可以在互联网上免费下载它（jetbrains.com/idea/download）
internet

48
00:01:23,840 --> 00:01:25,680
首先，我创建了一个名为 KotlinMinutes 的空文件
to start out with i created an empty

49
00:01:25,680 --> 00:01:27,840
首先，我创建了一个名为 KotlinMinutes 的空文件
file called KotlinMinutes

50
00:01:27,840 --> 00:01:29,600
Kotlin 文件的扩展名是 .kt
the file extension for Kotlin files is dot kt

51
00:01:29,600 --> 00:01:31,680
我们将在 main 这个特殊的函数中编写代码
and the code we write will be

52
00:01:31,680 --> 00:01:32,400
我们将在 main 这个特殊的函数中编写代码
inside this

53
00:01:32,400 --> 00:01:34,560
我们将在 main 这个特殊的函数中编写代码
special function called main

54
00:01:34,560 --> 00:01:36,000
关于函数，我们之后会讲更多
we'll talk more about functions later

55
00:01:36,000 --> 00:01:37,600
老规矩，我们要做的第一件事就是输出「你好，世界」
in classic fashion the first thing we'll

56
00:01:37,600 --> 00:01:39,040
老规矩，我们要做的第一件事就是输出「你好，世界」
do is print out "Hello world!"

57
00:01:39,040 --> 00:01:40,640
我们在这里调用 println() 函数并在双引号中输入 「Hello World!」
so we'll use this function called

58
00:01:40,640 --> 00:01:42,720
我们在这里调用 println() 函数并在双引号中输入 「Hello World!」
println and type in "Hello world!" in

59
00:01:42,720 --> 00:01:43,680
我们在这里调用 println() 函数并在双引号中输入 「Hello World!」
double quotes

60
00:01:43,680 --> 00:01:45,439
现在我们可以点击这个绿色箭头来编译并运行我们刚刚写好的代码
now we'll execute our code by hitting

61
00:01:45,439 --> 00:01:47,680
现在我们可以点击这个绿色箭头来编译并运行我们刚刚写好的代码
this green arrow which will compile and

62
00:01:47,680 --> 00:01:48,640
现在我们可以点击这个绿色箭头来编译并运行我们刚刚写好的代码
run our code

63
00:01:48,640 --> 00:01:50,479
编译的意思是用你写的代码生成计算机能执行的二进制文件
compiling just means taking the symbols

64
00:01:50,479 --> 00:01:51,920
编译的意思是用你写的代码生成计算机能执行的二进制文件
and keywords you write and turning that

65
00:01:51,920 --> 00:01:53,280
编译的意思是用你写的代码生成计算机能执行的二进制文件
into something that the computer can

66
00:01:53,280 --> 00:01:54,320
编译的意思是用你写的代码生成计算机能执行的二进制文件
actually execute

67
00:01:54,320 --> 00:01:56,240
你可以在弹出的运行工具窗口中看到程序的运行结果
you can see the output in this run tool

68
00:01:56,240 --> 00:01:57,920
在这里它输出了「Hello World!」，符合我们的预期
window that pops up where it says "Hello

69
00:01:57,920 --> 00:01:59,280
在这里它输出了「Hello World!」，符合我们的预期
world!" as we expect

70
00:01:59,280 --> 00:02:00,719
让我们从变量开始我们的 Kotlin 之旅
let's start our tour of Kotlin with variables

71
00:02:00,719 --> 00:02:03,040
变量是一组有名字的数据
a variable is a piece of data

72
00:02:03,040 --> 00:02:03,920
为了创建一个变量，你需要为它指定一个变量名和类型
which has a name and a type

73
00:02:03,920 --> 00:02:06,240
例如 string（字符串）类型，它由一串字符组成
for example strings are a

74
00:02:06,240 --> 00:02:07,520
例如 string（字符串）类型，它由一串字符组成
sequence of characters

75
00:02:07,520 --> 00:02:09,598
所以我的名字可以用 string 类型的变量来储存
so my first name would be stored as a as

76
00:02:09,598 --> 00:02:10,800
所以我的名字可以用 string 类型的变量来储存
a string type

77
00:02:10,800 --> 00:02:12,400
要定义一个变量，我们需要使用 val 关键字
the way we'll declare the variable is

78
00:02:12,400 --> 00:02:14,400
要定义一个变量，我们需要使用 val 关键字
with a special keyword called val

79
00:02:14,400 --> 00:02:15,840
从它在编辑器中被标以不同的颜色你就能知道，它是一个关键字
you can tell it's a keyword since it'll

80
00:02:15,840 --> 00:02:17,520
从它在编辑器中被标以不同的颜色你就能知道，它是一个关键字
turn a different color in the editor

81
00:02:17,520 --> 00:02:19,840
在 Kotlin 中，每个变量都必须属于一种类型
in Kotlin every variable must have a

82
00:02:19,840 --> 00:02:21,120
所以我们说 Kotlin 是静态类型语言
type that's why we say

83
00:02:21,120 --> 00:02:23,040
在这个例子中，这个变量名为 firstName
Kotlin is statically typed so in this

84
00:02:23,040 --> 00:02:24,959
在这个例子中，这个变量名为 firstName
example the name of the variable is

85
00:02:24,959 --> 00:02:27,200
类型为 string
firstName and the type is string

86
00:02:27,200 --> 00:02:28,720
因为我们在定义变量的同时就给这个变量赋了值「Rahul」（一个字符串）
because we're setting the value of the

87
00:02:28,720 --> 00:02:30,640
因为我们在定义变量的同时就给这个变量赋了值「Rahul」（一个字符串）
variable equal to Rahul right away

88
00:02:30,640 --> 00:02:32,319
我们其实不需要专门把这个变量定义为 string 类型
we actually don't need to specify that

89
00:02:32,319 --> 00:02:33,680
这就是 Kotlin 的实用功能之一——类型识别
this is of type string

90
00:02:33,680 --> 00:02:35,360
这就是 Kotlin 的实用功能之一——类型识别
this is a nice feature of Kotlin called

91
00:02:35,360 --> 00:02:37,040
这就是 Kotlin 的实用功能之一——类型识别
type inference where

92
00:02:37,040 --> 00:02:39,040
如果我们赋的值类型很明确，就不需要单独地定义它了
if it's obvious what the type is we

93
00:02:39,040 --> 00:02:40,480
如果我们赋的值类型很明确，就不需要单独地定义它了
don't need to explicitly

94
00:02:40,480 --> 00:02:42,160
如果我们赋的值类型很明确，就不需要单独地定义它了
indicate it there's also an important

95
00:02:42,160 --> 00:02:43,760
还有一个重要概念是只读变量和可写变量
concept of whether a variable is

96
00:02:43,760 --> 00:02:44,720
还有一个重要概念是只读变量和可写变量
read-only or

97
00:02:44,720 --> 00:02:46,959
还有一个重要概念是只读变量和可写变量
readable and writable if the value of a

98
00:02:46,959 --> 00:02:48,000
如果一个变量的值需要在它被初始化后被修改
variable can change

99
00:02:48,000 --> 00:02:49,760
如果一个变量的值需要在它被初始化后被修改
after it's initialized then we have to

100
00:02:49,760 --> 00:02:51,200
我们就需要使用 var 这个关键字来定义它（而不是 val）
declare it with this var

101
00:02:51,200 --> 00:02:53,519
每到假期我的体重都会增加，因为我吃了太多曲奇
keyword since my weight goes up every

102
00:02:53,519 --> 00:02:54,879
每到假期我的体重都会增加，因为我吃了太多曲奇
holiday season because of how many

103
00:02:54,879 --> 00:02:55,920
每到假期我的体重都会增加，因为我吃了太多曲奇
cookies i'm eating

104
00:02:55,920 --> 00:02:58,319
我们要用 var 来定义我的体重，但是我的名字
we'll use var for that but my first name

105
00:02:58,319 --> 00:02:59,280
永远不会变
will never change

106
00:02:59,280 --> 00:03:01,519
所以我们要用 val 来定义
so that'll be a val there are a few

107
00:03:01,519 --> 00:03:02,959
除了刚刚讲的字符串和整型外，Kotlin 还内置了几种数据类型
other built-in types in Kotlin in

108
00:03:02,959 --> 00:03:04,800
除了刚刚讲的字符串和整型外，Kotlin 还内置了几种数据类型
addition to string and integer which we

109
00:03:04,800 --> 00:03:05,519
除了刚刚讲的字符串和整型外，Kotlin 还内置了几种数据类型
just saw

110
00:03:05,519 --> 00:03:08,080
例如 double 是用来存储像 2.5 这样的小数的
for example double is for decimals like

111
00:03:08,080 --> 00:03:09,040
例如 double 是用来存储像 2.5 这样的小数的
2.5

112
00:03:09,040 --> 00:03:11,680
而布尔类型只有两种值——真或者假
and booleans only have two values either

113
00:03:11,680 --> 00:03:12,400
而布尔类型只有两种值——真或者假
true

114
00:03:12,400 --> 00:03:15,200
编写代码的过程中，为后人留下些备注有时是很有帮助的
or false as you write more code it's

115
00:03:15,200 --> 00:03:16,560
编写代码的过程中，为后人留下些备注有时是很有帮助的
sometimes helpful to leave yourself a

116
00:03:16,560 --> 00:03:18,159
它可以告诉将来的自己和别人你为什么这样写这段代码
note about why you wrote the code in a

117
00:03:18,159 --> 00:03:18,959
它可以告诉将来的你和别人你为什么这么写这段代码
certain way

118
00:03:18,959 --> 00:03:20,560
这些备注就叫注释，你可以用双斜杠（//）来让这行代码作为注释被计算机（编译器）忽略
these are called comments and you can

119
00:03:20,560 --> 00:03:23,280
这些备注就叫注释，你可以打出两个斜杠（//）来让这一行作为注释被计算机（编译器）忽略
leave a comment by using a double slash

120
00:03:23,280 --> 00:03:24,959
这些备注就叫注释，你可以打出两个斜杠（//）来让这一行作为注释被计算机（编译器）忽略
commented lines are ignored by the

121
00:03:24,959 --> 00:03:26,879
说完了变量，我们来讲讲运算符
computer now that we've talked about

122
00:03:26,879 --> 00:03:27,519
说完了变量，我们来讲讲运算符
variables

123
00:03:27,519 --> 00:03:29,360
说完了变量，我们来讲讲运算符
let's look at operators which allow us

124
00:03:29,360 --> 00:03:31,440
运算符我们对这些变量进行操作
to manipulate these variables

125
00:03:31,440 --> 00:03:33,680
例如，我们可以用加号（+）来把两个字符串连成一个更长的字符串
for example we can combine two strings

126
00:03:33,680 --> 00:03:35,440
例如，我们可以用加号（+）来把两个字符串连成一个更长的字符串
into a longer string with a plus sign

127
00:03:35,440 --> 00:03:37,599
这种操作被称为字符串串接
which is called concatenation here we're

128
00:03:37,599 --> 00:03:39,519
在这里我们把字符串 s1 和 s2 串接的结果存储在变量 combined 中并打印了出来
printing out the value of s1 plus

129
00:03:39,519 --> 00:03:41,840
在这里我们把字符串 s1 和 s2 串接的结果存储在变量 combined 中并打印了出来
s2 in this variable called combined so

130
00:03:41,840 --> 00:03:43,120
所以我们运行这个程序的时候我们就会得到“call me maybe”的输出
when we run the program we get the（Carly Rae Jepsen 的一首歌）

131
00:03:43,120 --> 00:03:44,640
所以我们运行这个程序的时候我们就会得到“call me maybe”的输出
result of call me maybe which is a

132
00:03:44,640 --> 00:03:46,080
它是 "call me " 和 "maybe" 串接的结果
concatenation of call me

133
00:03:46,080 --> 00:03:48,480
它是 "call me " 和 "maybe" 串接的结果
and maybe this is an example of a binary

134
00:03:48,480 --> 00:03:50,400
这是一种二目运算符，因为它需要输入两个值
operator because it takes in two inputs

135
00:03:50,400 --> 00:03:51,840
如你所料，还有几种用于数字的二目运算符
there are several different binary

136
00:03:51,840 --> 00:03:53,360
如你所料，还有几种用于数字的二目运算符
operators for numbers as you might

137
00:03:53,360 --> 00:03:54,000
如你所料，还有几种用于数字的二目运算符
expect

138
00:03:54,000 --> 00:03:55,920
我们可以把这里的两个整数 9 和 4 相加得到和 13
with two integers here having value nine

139
00:03:55,920 --> 00:03:57,280
我们可以把这里的两个整数 9 和 4 相加得到和 13
and four we can add them together and

140
00:03:57,280 --> 00:03:58,480
我们可以把这里的两个整数 9 和 4 相加得到和 13
get thirteen

141
00:03:58,480 --> 00:04:01,840
我们也可以用 n1 减去 n2、乘上 n2、除以 n2
we can also subtract them multiply them

142
00:04:01,840 --> 00:04:04,560
或使用百分号（%）获取 n1 除以 n2 的余数
divide them or find the remainder after

143
00:04:04,560 --> 00:04:06,319
或使用百分号（%）获取 n1 除以 n2 的余数
the division with this percent sign

144
00:04:06,319 --> 00:04:08,879
在这里取模运算的结果会是 1
that would be 1 in this case let's talk

145
00:04:08,879 --> 00:04:10,239
是时候再拓展一下字符串相关的知识了
a bit more about strings

146
00:04:10,239 --> 00:04:11,840
字符串是一个字符序列
strings are a sequence of characters and

147
00:04:11,840 --> 00:04:12,959
你可以用它实现很多有用的功能，例如通过下标取回字符串中特定位置的字符
there are a bunch of useful things you

148
00:04:12,959 --> 00:04:14,319
你可以用它实现很多有用的功能，例如通过下标取回字符串中特定位置的字符
can do with them for example

149
00:04:14,319 --> 00:04:16,160
你可以用它实现很多有用的功能，例如通过下标取回字符串中特定位置的字符
retrieving a character in the series by

150
00:04:16,160 --> 00:04:17,600
你可以用它实现很多有用的功能，例如通过下标取回字符串中特定位置的字符
indexing into the string

151
00:04:17,600 --> 00:04:19,680
Kotlin 的下标和大多数编程语言一样从 0 开始
like this in Kotlin like most other

152
00:04:19,680 --> 00:04:21,279
Kotlin 的下标和大多数编程语言一样从 0 开始
programming languages we start counting

153
00:04:21,279 --> 00:04:23,120
所以第一个字符K在下标为0的位置上，第二个字符O在下标为1的位置上
at zero so the first character K

154
00:04:23,120 --> 00:04:24,560
所以第一个字符K在下标为0的位置上，第二个字符O在下标为1的位置上
will be at position zero and the second

155
00:04:24,560 --> 00:04:26,400
所以第一个字符K在下标为0的位置上，第二个字符O在下标为1的位置上
character O will be position one in the

156
00:04:26,400 --> 00:04:28,000
我们可以看到KOTLIN的前两个字母被打印出来了
output we can see the first two

157
00:04:28,000 --> 00:04:30,639
我们也可以用 isEmpty() 方法来检查字符出是否为空
letters of Kotlin we can also check if a

158
00:04:30,639 --> 00:04:32,320
我们也可以用 isEmpty() 方法来检查字符出是否为空
string is empty using the method is

159
00:04:32,320 --> 00:04:34,000
它的返回值为布尔类型，即真或假
empty which returns a boolean true or

160
00:04:34,000 --> 00:04:34,880
它的返回值为布尔类型，即真或假
false value

161
00:04:34,880 --> 00:04:36,800
我们还可以在变量名后面加上 .length 来获取一个字符串的长度，返回值为整形
or we can get the length of a string

162
00:04:36,800 --> 00:04:38,880
我们还可以在变量名后面加上 .length 来获取一个字符串的长度，返回值为整形
which is an integer by using the dot

163
00:04:38,880 --> 00:04:39,919
我们还可以在变量名后面加上 .length 来获取一个字符串的长度，返回值为整形
length property

164
00:04:39,919 --> 00:04:42,160
运行时我们可以得知我的字符串不为空，因为其中有字符
if we run this we can see that my string

165
00:04:42,160 --> 00:04:43,919
运行时我们可以得知我的字符串不为空，因为其中有字符
Kotlin is not empty because it has

166
00:04:43,919 --> 00:04:44,560
运行时我们可以得知我的字符串不为空，因为其中有字符
characters

167
00:04:44,560 --> 00:04:46,080
字符串中有 6 个字母，因此字符串的长度为 6。
and there are six characters which is

168
00:04:46,080 --> 00:04:47,759
字符串中有 6 个字母，因此字符串的长度为 6。
why the length is six

169
00:04:47,759 --> 00:04:49,759
substring() 方法则会根据我们提供的起止下标从字符串中取出子串
another method is substring which will

170
00:04:49,759 --> 00:04:51,680
substring() 方法则会根据我们提供的起止下标从字符串中取出子串
extract a portion of the string between

171
00:04:51,680 --> 00:04:53,919
substring() 方法则会根据我们提供的起止下标从字符串中取出子串
the start and end index that we provide

172
00:04:53,919 --> 00:04:57,280
在这里 substring(2, 4) 会返回 TL
so substring with parameters 2 and 4

173
00:04:57,280 --> 00:05:00,080
因为我们从下标为 2 的 T 开始
will output TL because we will start at

174
00:05:00,080 --> 00:05:00,479
因为我们从下标为 2 的 T 开始
T

175
00:05:00,479 --> 00:05:04,080
往后取两位，取到下标为 3 的 L 为止，不包括下标为 4 的 I
which is index 2 include index 3 the l

176
00:05:04,080 --> 00:05:07,280
往后取两位，取到下标为 3 的 L 为止，不包括下标为 4 的 I
and then go up 2 but not include index 4

177
00:05:07,280 --> 00:05:08,560
往后取两位，取到下标为 3 的 L 为止，不包括下标为 4 的 I
the i

178
00:05:08,560 --> 00:05:10,080
当你写了更多 Kotlin 代码之后，有个实用的建议：
one really handy tip as you start

179
00:05:10,080 --> 00:05:12,000
当你写了更多 Kotlin 代码之后，有个实用的建议：
writing more Kotlin is to explore

180
00:05:12,000 --> 00:05:13,520
在你的变量名后面输入英文句点（.）来探索更多可用的方法
other methods available to you by

181
00:05:13,520 --> 00:05:15,199
在你的变量名后面输入英文句点（.）来探索更多可用的方法
hitting the dot or period

182
00:05:15,199 --> 00:05:17,280
在你的变量名后面输入英文句点（.）来探索更多可用的方法
after writing the name of your variable

183
00:05:17,280 --> 00:05:19,039
你会看见一个自动完成对话框
you'll get an auto complete dialog

184
00:05:19,039 --> 00:05:21,039
它会向你展示你能用这个变量做的所有操作
which shows you all the possible things

185
00:05:21,039 --> 00:05:22,560
它会向你展示你能用这个变量做的所有操作
you can do with this

186
00:05:22,560 --> 00:05:24,960
句号可能是 Kotlin 中最重要的符号之一
variable the period is probably one of

187
00:05:24,960 --> 00:05:27,199
句号可能是 Kotlin 中最重要的符号之一
the most important symbols in Kotlin

188
00:05:27,199 --> 00:05:29,520
因为它能让我们使用这种语言的自带功能
since it allows us to use the built-in

189
00:05:29,520 --> 00:05:31,680
因为它能让我们使用这种语言的自带功能
functionality of the language

190
00:05:31,680 --> 00:05:33,600
值得指出的是，你能使用的方法与你的变量类型有关
one thing worth pointing out is that the

191
00:05:33,600 --> 00:05:35,039
值得指出的是，你能使用的方法与你的变量类型有关
options and methods that you get

192
00:05:35,039 --> 00:05:37,280
值得指出的是，你能使用的方法与你的变量类型有关
will depend on the type of the variable

193
00:05:37,280 --> 00:05:38,800
例如这个 int 类型的变量适用的方法就与 string 类型不同
for example the options here

194
00:05:38,800 --> 00:05:40,320
例如这个 int 类型的变量适用的方法就与 string 类型不同
with the integer will be different than

195
00:05:40,320 --> 00:05:42,000
例如这个 int 类型的变量适用的方法就与 string 类型不同
what we had with the string

196
00:05:42,000 --> 00:05:44,160
关于字符串的最后一个知识点
one last point on the topic of strings

197
00:05:44,160 --> 00:05:45,759
我们常常想要在字符串中输出一个变量的值
we'll frequently want to print out the

198
00:05:45,759 --> 00:05:46,960
我们常常想要在字符串中输出一个变量的值
value of a variable

199
00:05:46,960 --> 00:05:49,120
这种情况下我们可以用美元符号（$）来进行字符串插值
inside a string for that we'll use the

200
00:05:49,120 --> 00:05:51,360
这种情况下我们可以用美元符号（$）来进行字符串插值
dollar sign to do string interpolation

201
00:05:51,360 --> 00:05:53,440
这里的美元符号表示我们想把这个变量名替换为这个字符串存储的值
the dollar sign means that we'll replace

202
00:05:53,440 --> 00:05:54,560
这里的美元符号表示我们想把这个变量名替换为这个字符串存储的值
the variable here

203
00:05:54,560 --> 00:05:56,080
这里的美元符号表示我们想把这个变量名替换为这个字符串存储的值
with the contents of it inside the

204
00:05:56,080 --> 00:05:58,160
运行程序，我们可以看到输出为
string so if we run this we can see the

205
00:05:58,160 --> 00:05:59,919
「The string is KOTLIN」，因为
output is "The string is KOTLIN" because

206
00:05:59,919 --> 00:06:01,440
字符串中储存的值
the value of my string

207
00:06:01,440 --> 00:06:03,759
是 KOTLIN。我们可以把串插值用于
is KOTLIN we can use interpolation for

208
00:06:03,759 --> 00:06:06,000
任何类型的变量
variables of any type

209
00:06:06,000 --> 00:06:07,759
接下来我们来讲讲条件语句
let's move on to conditionals which are

210
00:06:07,759 --> 00:06:09,840
这是一种根据条件决定是否执行特定代码的方法
a way to execute certain code depending

211
00:06:09,840 --> 00:06:10,960
这是一种根据条件决定是否执行特定代码的方法
on a condition

212
00:06:10,960 --> 00:06:12,880
if 语句是一种流控制
and if statement is an example of flow

213
00:06:12,880 --> 00:06:14,560
它会判断一个表达式的值是真还是假，且仅在它为真的情况下执行一些代码
control which will evaluate whether

214
00:06:14,560 --> 00:06:17,120
它会判断一个表达式的值是真还是假，且仅在它为真的情况下执行一些代码
a statement is true or false and execute

215
00:06:17,120 --> 00:06:19,360
它会判断一个表达式的值是真还是假，且仅在它为真的情况下执行一些代码
some code only if it's true

216
00:06:19,360 --> 00:06:21,840
例如，我们可以在 examScore 变量大于 70 时打印一条信息
for example we can print out a message

217
00:06:21,840 --> 00:06:22,479
例如，我们可以在 examScore 变量大于 70 时打印一条信息
if this

218
00:06:22,479 --> 00:06:25,280
例如，我们可以在 examScore 变量大于 70 时打印一条信息
exam score variable is greater than 70.

219
00:06:25,280 --> 00:06:27,440
因为变量的值 88 大于 70
because the value 88 is larger than 70

220
00:06:27,440 --> 00:06:29,199
我们运行这段代码时会看到「you passed!」
when we run the code we see "you passed!"

221
00:06:29,199 --> 00:06:30,560
因为 if 代码块内的语句被执行了
because we're running the code inside

222
00:06:30,560 --> 00:06:31,440
因为 if 代码块内的语句被执行了
the if block

223
00:06:31,440 --> 00:06:33,120
这里用于判断的可以是任何返回布尔类型（真或假）的表达式
the statement we're evaluating here can

224
00:06:33,120 --> 00:06:35,199
这里用于判断的可以是任何返回布尔类型（真或假）的表达式
be anything with a true or false return

225
00:06:35,199 --> 00:06:35,680
这里用于判断的可以是任何返回布尔类型（真或假）的表达式
value

226
00:06:35,680 --> 00:06:37,840
我们可以使用 examScore 大于 70
so for example we could do exams greater

227
00:06:37,840 --> 00:06:38,800
我们可以使用 examScore 大于 70
than 70

228
00:06:38,800 --> 00:06:41,360
或者大于等于（>=）、小于（<）、小于等于（<=）、
greater than or equal to less than less

229
00:06:41,360 --> 00:06:42,400
等于（==）、
than or equal to

230
00:06:42,400 --> 00:06:46,000
不等于（!=）一个值作为条件
equal to or not equal to a value

231
00:06:46,000 --> 00:06:47,520
现在我把条件改回 examScore 大于 70
i'll change this back to examScore

232
00:06:47,520 --> 00:06:49,280
如果我们想在这个条件不满足的时候做些什么怎么办？
greater than 70 but what if you want to

233
00:06:49,280 --> 00:06:51,199
如果我们想在这个条件不满足的时候做些什么怎么办？
do something if that condition fails

234
00:06:51,199 --> 00:06:53,039
要做到这一点，我们需要用到 else 代码块
for that we'll use an else block and the

235
00:06:53,039 --> 00:06:54,720
当这个条件为假时，在这个块里的代码会被执行
code inside of here will get run if the

236
00:06:54,720 --> 00:06:55,840
当这个条件为假时，在这个块里的代码会被执行
condition fails

237
00:06:55,840 --> 00:06:57,440
在这个例子中，这意味着 examScore
in this case that means that the examScore

238
00:06:57,440 --> 00:06:59,599
小于 70，所以我们将输出
is less than 70 so we'll print out

239
00:06:59,599 --> 00:07:00,479
 「You failed :(」
“you failed :("

240
00:07:00,479 --> 00:07:02,479
现在让我们把 examScore 的值改为 55
and now let's change the examScore to

241
00:07:02,479 --> 00:07:04,400
这会让 else 块内的代码被执行
55 which is something that will trigger

242
00:07:04,400 --> 00:07:06,560
这会让 else 块内的代码被执行，所以
the else block to run and so here in the

243
00:07:06,560 --> 00:07:07,840
在输出中你能看到 「You failed :(」的消息
output you can see the message

244
00:07:07,840 --> 00:07:10,800
我们经常需要用到很多变量
"you failed :(" we often want to hold a bunch

245
00:07:10,800 --> 00:07:12,000
我们经常需要用到很多变量
of variables at once

246
00:07:12,000 --> 00:07:14,080
这种情况我们可以使用集合而不是一个个定义
instead of defining them one at a time

247
00:07:14,080 --> 00:07:16,160
这种情况我们可以使用集合而不是一个个定义
for that we can use collections

248
00:07:16,160 --> 00:07:18,560
例如，我们可以用一个字符串集合来保存我的所有朋友的名字
for example instead of having a separate

249
00:07:18,560 --> 00:07:19,599
例如，我们可以用一个字符串集合来保存我的所有朋友的名字
variable here

250
00:07:19,599 --> 00:07:21,599
例如，我们可以用一个字符串集合来保存我的所有朋友的名字
for each of my friends names we can have

251
00:07:21,599 --> 00:07:23,759
而不是为每个名字单独定义一个变量
one variable which is a list of strings

252
00:07:23,759 --> 00:07:25,440
而不是为每个名字单独定义一个变量
containing all my friends names

253
00:07:25,440 --> 00:07:26,880
如果需要打印出列表中的第三个元素我们可以
so now if i wanted to print out the

254
00:07:26,880 --> 00:07:28,880
如果需要打印出列表中的第三个元素我们可以
third element in this list we could do

255
00:07:28,880 --> 00:07:29,280
如果需要打印出列表中的第三个元素我们可以
that

256
00:07:29,280 --> 00:07:32,720
查找名字列表中的索引 2
by looking at index 2 of our names list

257
00:07:32,720 --> 00:07:35,199
记住 Kotlin 是从 0 开始计数的，所以 Ali
remember that Kotlin is 0 indexed so Ali

258
00:07:35,199 --> 00:07:36,400
在第 0 个位置
is at index 0

259
00:07:36,400 --> 00:07:39,199
Maya 在第 1 个，Chen 在第二个。当
Maya index 1 and Chen at index 2. when

260
00:07:39,199 --> 00:07:39,840
当我们运行这个
we run this

261
00:07:39,840 --> 00:07:42,639
我们可以马上在输出处看到 「Chen」
we do indeed see Chen in the output

262
00:07:42,639 --> 00:07:43,440
正常情况下
by default

263
00:07:43,440 --> 00:07:45,280
Kotlin 中的集合是只读的
collections in Kotlin are immutable

264
00:07:45,280 --> 00:07:47,039
意味着我们不能从中新增或移除元素
which means we can't add or remove

265
00:07:47,039 --> 00:07:48,400
意味着我们不能从中新增或移除元素
elements from the list

266
00:07:48,400 --> 00:07:50,080
如果我们想修改列表中的内容，我们
if we want to change the contents we

267
00:07:50,080 --> 00:07:52,479
必须把它定义成可变的列表
must declare the list as a mutable list

268
00:07:52,479 --> 00:07:54,400
修改定义部分（加上mutable）后我们
by changing the declaration now we are

269
00:07:54,400 --> 00:07:56,080
可以往里添加第四个元素
able to add a fourth element

270
00:07:56,080 --> 00:07:57,840
集合中的所有元素类型必须相同，所以在这里它们都是 string 类型
all elements in a collection must have

271
00:07:57,840 --> 00:07:59,360
集合中的所有元素类型必须相同，所以在这里它们都是 string 类型
the same type so in this example

272
00:07:59,360 --> 00:08:00,800
集合中的所有元素类型必须相同，所以在这里它们都是 string 类型
everything is of type string

273
00:08:00,800 --> 00:08:02,240
实际上我们把 string 类型参数加到定义部分来明确这一点
and we could actually make that explicit

274
00:08:02,240 --> 00:08:04,560
实际上我们把 string 类型参数加到定义部分来明确这一点
by adding this string type parameter

275
00:08:04,560 --> 00:08:06,400
实际上我们把 string 类型参数加到定义部分来明确这一点
to the declaration if we tried adding

276
00:08:06,400 --> 00:08:07,919
如果我们尝试往列表中新增其他类型的元素，会出现编译错误
something else into the list we would

277
00:08:07,919 --> 00:08:09,919
如果我们尝试往列表中新增其他类型的元素，会出现编译错误
get a compile error for example

278
00:08:09,919 --> 00:08:11,919
例如这里我们尝试向列表中添加整数「80」
here we're trying to add 80 which is an

279
00:08:11,919 --> 00:08:12,960
例如这里我们尝试向列表中添加整数「80」
integer into the list

280
00:08:12,960 --> 00:08:15,039
把鼠标移到上方，提示「整型数字不符合预期的 string 类型」
and if i hover over it says the integer

281
00:08:15,039 --> 00:08:16,800
把鼠标移到上方，提示「整型数字不符合预期的 string 类型」
literal does not conform to the expected

282
00:08:16,800 --> 00:08:17,199
把鼠标移到上方，提示「整型数字不符合预期的 string 类型」
type

283
00:08:17,199 --> 00:08:19,120
对集合中的每个元素进行操作是很常见的
string it's really common to do

284
00:08:19,120 --> 00:08:20,560
对集合中的每个元素进行操作是很常见的
something on every element

285
00:08:20,560 --> 00:08:22,400
for 循环是实现它最常见的方法
in a collection the most common way of

286
00:08:22,400 --> 00:08:24,319
for 循环是实现它最常见的方法
doing that is with a for loop

287
00:08:24,319 --> 00:08:26,400
例如，如果我们想打印出朋友名单这个列表里的每个元素
for example if we wanted to print out

288
00:08:26,400 --> 00:08:28,080
例如，如果我们想打印出朋友名单这个列表里的每个元素
each element in our list of friends

289
00:08:28,080 --> 00:08:28,720
例如，如果我们想打印出朋友名单这个列表里的每个元素
names

290
00:08:28,720 --> 00:08:30,479
我们可以像这样写一个 for 循环
we'd write the for loop like this for

291
00:08:30,479 --> 00:08:31,919
for (name in names)
name in names

292
00:08:31,919 --> 00:08:35,039
println(name) 如果我们运行这段代码，我们能看到
println(name) if we run this we can see

293
00:08:35,039 --> 00:08:36,719
程序输出了列表中的三个名字
the output is the three names in the

294
00:08:36,719 --> 00:08:38,880
在每次循环中，name 变量都会从 names 列表中取出一个元素
list the way i think about this

295
00:08:38,880 --> 00:08:41,440
在每次循环中，name 变量都会从 names 列表中取出一个元素
is that in every cycle or iteration of

296
00:08:41,440 --> 00:08:42,399
在每次循环中，name 变量都会从 names 列表中取出一个元素
the for loop

297
00:08:42,399 --> 00:08:44,640
在每次循环中，name 变量都会从 names 列表中取出一个元素
the variable name will take on one

298
00:08:44,640 --> 00:08:46,160
在每次循环中，name 变量都会从 names 列表中取出一个元素
element of the list

299
00:08:46,160 --> 00:08:48,640
它会依次输出，所以第一个是 Ali
it'll go in order so first it'll be Ali

300
00:08:48,640 --> 00:08:51,120
然后是 Maya，最后是 Chen
then Maya and then Chen

301
00:08:51,120 --> 00:08:53,200
for 循环的另一种用处是重复一个操作若干次
the other common use of for loops is to

302
00:08:53,200 --> 00:08:55,279
for 循环的另一种用处是重复做一事若干次
do something a certain number of times

303
00:08:55,279 --> 00:08:58,959
我们可以用 for(i in 1..5) 来执行某项操作五次
we can use for i in 1.5 to execute

304
00:08:58,959 --> 00:08:59,360
我们可以用 for(i in 1..5) 来执行某项操作五次
something

305
00:08:59,360 --> 00:09:01,519
我们可以用 for(i in 1..5) 来执行某项操作五次
exactly five times so if you run this we

306
00:09:01,519 --> 00:09:02,880
如果你运行这个程序，就能看到我们重复执行了 println(i) 五次，每次都会输出 i 的值
can see that the operation that we're

307
00:09:02,880 --> 00:09:04,000
如果你运行这个程序，就能看到我们重复执行了 println(i) 五次，每次都会输出 i 的值
doing five times

308
00:09:04,000 --> 00:09:06,720
如果你运行这个程序，就能看到我们重复执行了 println(i) 五次，每次都会输出 i 的值
is println and we're printing out i each

309
00:09:06,720 --> 00:09:07,040
在程序跳出循环前，i 的值会从 1 到 5 按顺序变化
time

310
00:09:07,040 --> 00:09:08,959
在程序跳出循环前，i 的值会从 1 到 5 按顺序变化
where i will take on each of the values

311
00:09:08,959 --> 00:09:11,519
在程序跳出循环前，i 的值会从 1 到 5 按顺序变化
1 through 5 before it exits the for loop

312
00:09:11,519 --> 00:09:13,200
如果我们不想打印最后一个数字，我们可以这么写：
if we don't want to include the last

313
00:09:13,200 --> 00:09:16,000
for(i in 1 until 5)
number then we can do for(i in 1 until 5)

314
00:09:16,000 --> 00:09:17,200
这样就只会输出 1 到 4 了
and that will just print out the numbers

315
00:09:17,200 --> 00:09:18,320
这样就只会输出 1 到 4 了
1 through 4.

316
00:09:18,320 --> 00:09:20,160
然后，我们来讲解函数/子程序
next we'll talk about functions

317
00:09:20,160 --> 00:09:22,000
你可以把需要重复使用的代码写成函数，这样在整个程序中就都能调用它了
functions are a way to combine chunks of

318
00:09:22,000 --> 00:09:23,519
你可以把需要重复使用的代码写成函数，这样在整个程序中就都能调用它了
your code so we can reuse them

319
00:09:23,519 --> 00:09:25,040
你可以把需要重复使用的代码写成函数，这样在整个程序中就都能调用它了
throughout our program

320
00:09:25,040 --> 00:09:27,040
这能让我们的代码更容易被阅读和理解
this makes our code easier to read and

321
00:09:27,040 --> 00:09:28,800
我们可以用 fun 关键词 + 函数名来创建一个函数
think about we can create a function

322
00:09:28,800 --> 00:09:30,399
我们可以用 fun 关键词 + 函数名来创建一个函数
with the fun keyword followed by the

323
00:09:30,399 --> 00:09:31,279
我们可以用 fun 关键词 + 函数名来创建一个函数
function name

324
00:09:31,279 --> 00:09:32,800
在这里我叫它 myFunction
so in this example it's myFunction

325
00:09:32,800 --> 00:09:35,200
函数名后面跟上一对小括号
followed by open and close parentheses

326
00:09:35,200 --> 00:09:36,640
然后把函数体包裹在花括号内
and then the body of the function goes

327
00:09:36,640 --> 00:09:38,560
然后把函数体包裹在花括号内
inside of these curly braces

328
00:09:38,560 --> 00:09:40,320
现在我们就可以在主函数中调用 myFunction 了，在函数名后面加上一对括号即可
now we can invoke our function from the

329
00:09:40,320 --> 00:09:41,680
现在我们就可以在主函数中调用 myFunction 了，在函数名后面加上一对括号即可
main function just by

330
00:09:41,680 --> 00:09:42,959
现在我们就可以在主函数中调用 myFunction 了，在函数名后面加上一对括号即可
calling it with the open and closed

331
00:09:42,959 --> 00:09:44,959
当我们运行这个程序时，myFunction 中的代码被运行，所以它输出了 hello
parenthesis if we run this the body of

332
00:09:44,959 --> 00:09:45,920
当我们运行这个程序时，myFunction 中的代码被运行，所以它输出了 hello
my function gets

333
00:09:45,920 --> 00:09:47,920
当我们运行这个程序时，myFunction 中的代码被运行，所以它输出了 hello
executed so we print out hello if we

334
00:09:47,920 --> 00:09:50,000
如果我们想给这个函数一些输入
want to give this function some input we

335
00:09:50,000 --> 00:09:51,839
我们可以把参数名称和类型加到函数原型中
can add the parameter name and type to

336
00:09:51,839 --> 00:09:52,880
我们可以把参数名称和类型加到函数原型中
the function signature

337
00:09:52,880 --> 00:09:54,560
所以这里我们增加了一个 String 类型的名为 name 的参数
so here we have a parameter name of name

338
00:09:54,560 --> 00:09:55,920
所以这里我们增加了一个 String 类型的名为 name 的参数
and the type of string

339
00:09:55,920 --> 00:09:57,600
然后在函数体中我们可以将传入的参数当作普通的变量使用
in the body of the function we can treat

340
00:09:57,600 --> 00:09:59,519
然后在函数体中我们可以将传入的参数当作普通的变量使用
the parameter as a normal variable

341
00:09:59,519 --> 00:10:02,399
所以现在我们把输入的名字加进了 print 方法中
so here we're including that input into

342
00:10:02,399 --> 00:10:03,279
所以现在我们把输入的名字加进了 print 方法中
the print line

343
00:10:03,279 --> 00:10:04,800
你会发现主函数中我们尝试调用子函数的地方有个错误
you'll notice back in the main function

344
00:10:04,800 --> 00:10:06,160
你会发现主函数中我们尝试调用子函数的地方有个错误
that we now have an error when trying to

345
00:10:06,160 --> 00:10:06,640
你会发现主函数中我们尝试调用子函数的地方有个错误
call

346
00:10:06,640 --> 00:10:09,120
这是因为调用这个函数时需要传入正确类型和数量的参数
my function and that's because whoever

347
00:10:09,120 --> 00:10:10,320
这是因为调用这个函数时需要传入正确类型和数量的参数
invokes this function

348
00:10:10,320 --> 00:10:12,000
这是因为调用这个函数时需要传入正确类型和数量的参数
is responsible for passing in the

349
00:10:12,000 --> 00:10:13,600
这是因为调用这个函数时需要传入正确类型和数量的参数
correct number and type

350
00:10:13,600 --> 00:10:16,240
让我们传入字符串 “Jay” 作为参数
of parameters let's pass in the string Jay

351
00:10:16,240 --> 00:10:18,079
运行程序，我们可以看到它输出了 “hello, Jar"
for the parameter and if we run this now

352
00:10:18,079 --> 00:10:18,800
运行程序，我们可以看到它输出了 “hello, Jar"
we can see

353
00:10:18,800 --> 00:10:21,360
运行程序，我们可以看到它输出了 “hello, Jar"
hello j as the output we can also set

354
00:10:21,360 --> 00:10:22,880
我们也可以把函数设为 private，这样从其它类或者文件中就无法调用它了
the visibility of functions to be

355
00:10:22,880 --> 00:10:24,720
我们也可以把函数设为 private，这样从其它类或者文件中就无法调用它了
private so they can't be accessed from

356
00:10:24,720 --> 00:10:26,320
我们也可以把函数设为 private，这样从其它类或者文件中就无法调用它了
other classes or files

357
00:10:26,320 --> 00:10:28,079
观众总是问我「你私下里有什么娱乐活动」，但这就得留给另一个视频来讲了
people always ask me what kind of

358
00:10:28,079 --> 00:10:29,680
观众总是问我「你私下里有什么娱乐活动」，但这就得留给另一个视频来讲了
private fun are you having

359
00:10:29,680 --> 00:10:32,399
观众总是问我「你私下里有什么娱乐活动」，但这就得留给另一个视频来讲了
but that's the topic for another video

360
00:10:32,399 --> 00:10:34,480
最后，Null 的概念在 Kotlin 中很重要
finally the concept of null is really

361
00:10:34,480 --> 00:10:35,920
最后，Null 的概念在 Kotlin 中很重要
important in Kotlin

362
00:10:35,920 --> 00:10:38,160
Null 的意思是没有值（空），如果你想允许一个变量没有值
null means having no value and if a

363
00:10:38,160 --> 00:10:40,000
Null 的意思是没有值（空），如果你想允许一个变量没有值
variable is allowed to have no value

364
00:10:40,000 --> 00:10:41,600
我们需要在类型后面加上一个英文半角问号（?）
then we need to update the type to

365
00:10:41,600 --> 00:10:43,279
我们需要在类型后面加上一个英文半角问号（?）
include a question mark

366
00:10:43,279 --> 00:10:45,279
这意味着 instagramBio 是个可空的字符串
this means that the variable instagramBio

367
00:10:45,279 --> 00:10:47,279
这意味着 instagramBio 是个可空的字符串
instagramBio is a nullable string

368
00:10:47,279 --> 00:10:49,200
如果你在 Instagram 上写了 Bio
so on instagram if you've written a bio

369
00:10:49,200 --> 00:10:50,720
这个变量会有一个字符串型的值
then this variable would have a string

370
00:10:50,720 --> 00:10:51,279
这个变量会有一个字符串型的值
value

371
00:10:51,279 --> 00:10:53,839
但是如果它没被设置，它的值就会是 null
but if it's not set it would be null the

372
00:10:53,839 --> 00:10:54,880
需要牢记的是，我们不能在值为 null 的变量上调用任何方法
important thing to remember

373
00:10:54,880 --> 00:10:56,880
需要牢记的是，我们不能在值为 null 的变量上调用任何方法
is that we can't call any methods on

374
00:10:56,880 --> 00:10:57,920
需要牢记的是，我们不能在值为 null 的变量上调用任何方法
something which is null

375
00:10:57,920 --> 00:10:59,920
避免这个问题的方法是在调用成员函数前先用 if 检查变量的值是否为 null
one way to get around this is to check

376
00:10:59,920 --> 00:11:01,440
避免这个问题的方法是在调用成员函数前先用 if 检查变量的值是否为 null
if the variable is not null

377
00:11:01,440 --> 00:11:02,640
然后在 if 语句的花括号里我们就能安全地调用我们想调用的方法了
and then in the body of this if

378
00:11:02,640 --> 00:11:04,240
然后在 if 语句的花括号里我们就能安全地调用我们想调用的方法了
statement we can now safely call any

379
00:11:04,240 --> 00:11:05,440
然后在 if 语句的花括号里我们就能安全地调用我们想调用的方法了
method we want

380
00:11:05,440 --> 00:11:07,279
在这个例子中，因为我们给 instagramBio 赋了值 null
in this case because we're setting

381
00:11:07,279 --> 00:11:08,800
在这个例子中，因为我们给 instagramBio 赋了值 null
instagramBio to null

382
00:11:08,800 --> 00:11:10,560
我们无法通过第三行的检查，所以运行程序时什么也不会输出
we'll fail the check on line 3 which

383
00:11:10,560 --> 00:11:12,000
我们无法通过第三行的检查，所以运行程序时什么也不会输出
means when we run the program we get an

384
00:11:12,000 --> 00:11:13,360
我们无法通过第三行的检查，所以运行程序时什么也不会输出
empty output

385
00:11:13,360 --> 00:11:15,360
如果我们给 instagramBio 赋值一个
however if we update instagramBio to be

386
00:11:15,360 --> 00:11:17,519
字符串，我们就能进入 if 语句，所以它现在输出了大写的 GROWTH
a string then we will get into the body

387
00:11:17,519 --> 00:11:18,000
字符串，我们就能进入 if 语句，所以它现在输出了大写的 GROWTH
of the

388
00:11:18,000 --> 00:11:19,200
字符串，我们就能进入 if 语句，所以它现在输出了大写的 GROWTH
if statement and that's how we're

389
00:11:19,200 --> 00:11:21,440
字符串，我们就能进入 if 语句，所以它现在输出了大写的 GROWTH
printing out uppercase GROWTH

390
00:11:21,440 --> 00:11:24,000
我们也可以通过简写把三行简略为一行，在变量名后加个问号就行了
the other way of doing this is to use a

391
00:11:24,000 --> 00:11:25,920
我们也可以通过简写把三行简略为一行，在变量名后加个问号就行了
shorthand for exactly this if

392
00:11:25,920 --> 00:11:28,079
我们也可以通过简写把三行简略为一行，在变量名后加个问号就行了
check which is the question mark dot

393
00:11:28,079 --> 00:11:30,079
所以我们可以这么写：instagramBio?.toUpperCase()
operator so we can say instagram bio

394
00:11:30,079 --> 00:11:32,560
所以我们可以这么写：instagramBio?.toUpperCase()
question mark dot to upper case and this

395
00:11:32,560 --> 00:11:34,640
这意味着只有在变量/对象的值不为 null 时这个成员函数才会被调用
means we'll only call this method

396
00:11:34,640 --> 00:11:37,040
这意味着只有在变量/对象的值不为 null 时这个成员函数才会被调用
on this variable or this object if it's

397
00:11:37,040 --> 00:11:38,160
这意味着只有在变量/对象的值不为 null 时这个成员函数才会被调用
non-null

398
00:11:38,160 --> 00:11:40,240
因为我们用不同的方法写了两遍，现在运行程序我们可以看到它输出了两次 GROWTH
so if we print this out we can see that

399
00:11:40,240 --> 00:11:42,000
因为我们用不同的方法写了两遍，现在运行程序我们可以看到它输出了两次 GROWTH
we now get growth in uppercase

400
00:11:42,000 --> 00:11:44,560
这些差不多就是 Kotlin 的核心了
printed out twice that's pretty much the

401
00:11:44,560 --> 00:11:45,519
这些差不多就是 Kotlin 的核心了
core of Kotlin

402
00:11:45,519 --> 00:11:48,000
我们简单讲了变量、操作符、字符串
we went over variables operators strings

403
00:11:48,000 --> 00:11:50,240
if 语句、for 循环和函数
if statements for loops and functions

404
00:11:50,240 --> 00:11:51,680
如果你想观看更多关于 Kotlin 的视频
if you're interested in learning more

405
00:11:51,680 --> 00:11:53,760
如果你想观看更多关于 Kotlin 的视频
about all the good stuff in Kotlin

406
00:11:53,760 --> 00:11:55,360
记得给这个视频点赞并订阅 Rahul Pandey 的频道，感谢大家的收看，我们就下次再见，拜拜
i'd love if you hit the subscribe button

407
00:11:55,360 --> 00:11:57,519
记得给这个视频点赞并订阅 Rahul Pandey 的频道，感谢大家的收看，我们就下次再见，拜拜
and like this video thanks for watching

408
00:11:57,519 --> 00:12:01,760
记得给这个视频点赞并订阅 Rahul Pandey 的频道，感谢大家的收看，我们就下次再见，拜拜
and i'll see you in the next one