在 Kotlin 中创建和使用变量

1. 开始之前

在您手机上使用的应用中，请注意应用的某些部分保持不变，而其他部分则会发生变化（或称为变量）。

例如，设置应用中类别的名称保持不变 - 网络和互联网、已连接的设备、应用等。

另一方面，如果您查看新闻应用，文章会经常变化。文章名称、来源、发布日期和图片都会变化。

如何编写代码以使内容随时间推移而变化？您无法在每次发布新文章时都重写应用中的代码，而这每天、每小时、每分钟都在发生！

在本 Codelab 中，您将学习如何编写使用变量的代码，以便程序的某些部分可以在无需编写全新的指令集的情况下发生变化。您将像在之前的 Codelab 中一样使用 Kotlin Playground。

您将构建的内容

• 使用变量的简短 Kotlin 程序。

您将学到的内容

• 如何定义变量并更新其值。
• 如何从 Kotlin 中的基本数据类型中选择合适的变量数据类型。
• 如何在代码中添加注释。

您需要什么

• 一台连接互联网的电脑和一个网页浏览器。

2. 变量和数据类型

在计算机编程中，存在变量的概念，它是一个用于存储单个数据片段的容器。您可以将其想象成一个包含值的盒子。这个盒子有一个标签，即变量的名称。通过使用名称引用该盒子，您可以访问它包含的值。

当您可以直接使用值时，为什么要将值存储在盒子中并通过其名称引用盒子？问题在于，当您的代码在所有指令中直接使用值时，您的程序将仅适用于该特定情况。

以下类比可以帮助您更容易理解变量为什么有用。以下是一封您最近认识的人的信件。

亲爱的劳伦，

今天在办公室见到您真是太好了。我期待着星期五见到您。

祝您愉快！

这封信很好，但它仅适用于您与劳伦的特定情况。如果您发现自己需要多次编写相同的信件，但针对不同的人略有改动，该怎么办？创建单个信件模板会更有效率，将可变部分留空。

亲爱的 ____ ，

今天在 ____ 见到您真是太好了。我期待着在 ____ 见到您。

祝您愉快！

您还可以指定每个空格中包含的信息类型。这确保了信件模板将按预期使用。

亲爱的 {姓名} ，

今天在 {地点} 见到您真是太好了。我期待着在 {日期} 见到您。

祝您愉快！

从概念上讲，构建应用类似。您为某些数据设置了占位符，而应用的其他部分保持不变。

在上图所示的新闻应用中，“欢迎”文本、“最新新闻”标题和“查看更多文章”按钮文本始终保持不变。相反，用户的姓名和每篇文章的内容会发生变化，因此这是一个很好的机会，可以使用变量来保存每个信息片段。

您不希望编写应用中的代码（或指令）仅适用于名为 Alex 的用户，或者始终具有相同标题和发布日期的新闻文章。相反，您希望一个更灵活的应用，因此您应该通过引用变量名称（如 name、article1Name、article1Date 等）来编写代码。然后，您的代码变得足够通用，可以适用于许多不同的用例，其中用户的姓名可能不同，文章的详细信息也可能不同。

包含变量的示例应用

让我们来看一个应用示例，看看它可能在哪些地方使用变量。

在地图应用中，您可能会找到每个位置的详细信息屏幕，例如餐厅或企业。Google 地图应用中上面的屏幕截图显示了 Google 公司总部的详细信息，称为 Googleplex。您认为哪些数据片段存储在应用中的变量中？

• 位置的名称
• 位置的星级评分
• 位置的评论数量
• 用户是否保存（或收藏）了此位置
• 位置的地址

更改存储在这些变量中的数据，您将拥有一个足够灵活的地图应用，也可以显示其他位置的详细信息。

数据类型

当您决定应用的哪些方面可以是变量时，务必指定这些变量可以存储哪种类型的数据。在 Kotlin 中，有一些常见的基本数据类型。下表显示了每一行中不同的数据类型。对于每种数据类型，都描述了它可以保存哪种数据以及示例值。

现在您已经了解了一些常见的 Kotlin 数据类型，对于您之前看到的那个位置详细信息页面中标识的每个变量，哪种数据类型是合适的？

• 位置的名称是文本，因此可以存储在数据类型为 String 的变量中。
• 位置的星级评分是十进制数（例如 4.2 星），因此可以存储为 Double。
• 位置的评论数量是整数，因此应存储为 Int。
• 用户是否保存了此位置只有两个可能的值（已保存或未保存），因此存储为 Boolean，其中 true 和 false 可以分别表示这些状态。
• 位置的地址是文本，因此应为 String。

在下面的两个场景中练习。在以下应用中识别变量的使用及其数据类型。

1. 在用于观看视频的应用（例如 YouTube 应用）中，有一个视频详细信息屏幕。变量可能在哪里使用？这些变量的数据类型是什么？

没有唯一的正确答案，但在观看视频的应用中，变量可用于以下数据片段

• 视频的名称（String）
• 频道的名称（String）
• 视频的观看次数（Int）
• 视频的点赞数（Int）
• 视频的评论数（Int）

2. 在像 Messages 这样的应用中，屏幕会列出最近收到的短信。变量可能在哪里使用？这些变量的数据类型是什么？

同样，没有唯一的正确答案。在短信应用中，变量可用于以下数据片段

• 发送者的电话号码（String）
• 消息的时间戳（String）
• 消息内容的预览（String）
• 短信是否未读（Boolean）

试一试

1. 在手机上打开您最喜欢的应用。
2. 确定您认为应用在该特定屏幕上使用了变量的位置。
3. 猜测这些变量的数据类型。
4. 在社交媒体上分享您的答案，并附上应用的 屏幕截图，解释您认为变量使用的位置，以及标签 #AndroidBasics。

在本 Codelab 中到目前为止做得很好！继续下一部分，了解如何在代码中使用变量和数据类型。

3. 定义和使用变量

定义与使用变量

在使用变量之前，必须先在代码中定义它。这类似于您在上一个 Codelab 中学习的关于在调用函数之前定义函数的内容。

当您定义变量时，您会为其分配一个名称以唯一标识它。您还可以通过指定数据类型来决定它可以保存哪种类型的数据。最后，您可以提供一个将存储在变量中的初始值，但这可选。

定义变量后，您可以在程序中使用该变量。要使用变量，请在代码中键入变量名称，这会告诉 Kotlin 编译器您希望在代码中的该点使用变量的值。

例如，定义一个变量来存储用户收件箱中未读消息的数量。该变量可以命名为count。在变量中存储一个值，例如数字2，表示用户收件箱中有2条未读消息。（您可以选择在变量中存储其他数字，但为了本例的目的，请使用数字2。）

每次您的代码需要访问未读消息的数量时，请在代码中键入count。在执行您的指令时，Kotlin 编译器会看到代码中的变量名，并使用变量值替换它。

从技术上讲，有更具体的词汇来描述此过程。

表达式是计算出一个值的代码小单元。表达式可以由变量、函数调用等组成。在以下情况下，表达式由一个变量组成：count变量。此表达式计算结果为2。

计算表示确定表达式的值。在本例中，表达式计算结果为2。编译器会计算代码中的表达式，并在执行程序中的指令时使用这些值。

要观察 Kotlin Playground 中的这种行为，请运行下一节中的程序。

示例

1. 在 Web 浏览器中打开Kotlin Playground。
2. 将 Kotlin Playground 中的现有代码替换为以下程序。

此程序创建一个名为count的变量，其初始值为2，并通过将count变量的值打印到输出中来使用它。如果您还没有理解代码语法的所有方面，请不要担心。将在后续章节中详细解释。

fun main() {
    val count: Int = 2
    println(count)
}

3. 运行程序，输出应为

2

变量声明

在您运行的程序中，代码的第二行表示

val count: Int = 2

此语句创建一个名为count的整数变量，该变量保存数字2。

熟悉阅读 Kotlin 中声明变量的语法（或格式）可能需要一段时间。下图显示了有关变量的每个细节应该位于哪里，以及空格和符号的位置。

在count变量示例的上下文中，您可以看到变量声明以单词val开头。变量的名称是count。数据类型是Int，初始值为2。

下面将详细解释变量声明的每个部分。

定义新变量的关键字

要定义一个新变量，请以 Kotlin 关键字val（代表值）开头。然后 Kotlin 编译器就知道此语句中包含变量声明。

变量名

就像您命名函数一样，您也需要命名变量。在变量声明中，变量名位于val关键字之后。

您可以选择任何您想要的变量名，但最佳实践是避免使用 Kotlin 关键字作为变量名。

最好选择一个描述变量保存数据的名称，以便您的代码更易于阅读。

变量名应遵循驼峰命名法，就像您在函数名中学习的那样。变量名的第一个单词全部小写。如果名称中有多个单词，则单词之间没有空格，并且所有其他单词应以大写字母开头。

变量名示例

• numberOfEmails
• cityName
• bookPublicationDate

对于前面显示的代码示例，count是变量的名称。

val count: Int = 2

变量数据类型

在变量名之后，添加一个冒号、一个空格，然后是变量的数据类型。如前所述，String、Int、Double、Float和Boolean是一些基本的 Kotlin 数据类型。您将在本课程的后面学习更多数据类型。请记住，数据类型的拼写必须与显示的完全相同，并且每个数据类型都以大写字母开头。

对于count变量示例，Int是变量的数据类型。

val count: Int = 2

赋值运算符

在变量声明中，等号符号（=）位于数据类型之后。等号符号称为赋值运算符。赋值运算符将值赋给变量。换句话说，等号右侧的值将存储在等号左侧的变量中。

变量初始值

变量值是存储在变量中的实际数据。

对于count变量示例，数字2是变量的初始值。

val count: Int = 2

您可能还会听到这样的短语：“count变量初始化为2。”这意味着2是声明变量时存储在变量中的第一个值。

初始值将根据为变量声明的数据类型而有所不同。

请参阅以下表格，您可能在代码实验室的前面部分认出了它。第三列显示了可以存储在每种对应类型变量中的示例值。这些值称为字面量，因为它们是固定或常量值（该值始终相同）。例如，整数 32 始终具有 32 的值。相反，变量不是字面量，因为其值可以更改。您可能会根据其类型听到这些字面量的称呼：字符串字面量、整数字面量、布尔字面量等。

根据变量的数据类型提供适当且有效的值非常重要。例如，您不能将像"Hello"这样的字符串字面量存储在类型为Int的变量中，因为 Kotlin 编译器会给您一个错误。

使用变量

以下是您在 Kotlin Playground 中运行的原始程序。到目前为止，您已经了解代码的第二行创建了一个名为count的新整数变量，其值为2。

fun main() {
    val count: Int = 2
    println(count)
}

现在查看代码的第三行。您正在将count变量打印到输出中

println(count)

请注意，count一词周围没有引号。它是一个变量名，而不是字符串字面量。（如果它是字符串字面量，则会在该词周围找到引号。）当您运行程序时，Kotlin 编译器会为println()指令计算括号内的表达式，即count。由于表达式的计算结果为2，则使用2作为输入调用println()方法：println(2)。

因此，程序的输出为

2

输出中的数字本身并不是很有用。在输出中打印更详细的消息来解释2的含义会更有帮助。

字符串模板

在输出中显示的更有帮助的消息是

You have 2 unread messages.

请按照以下步骤操作，以便程序输出更有帮助的消息。

1. 使用以下代码更新 Kotlin Playground 中的程序。对于println()调用，传入一个包含count变量名的字符串字面量。请记住用引号括住文本。请注意，这不会为您提供您期望的结果。您将在后面的步骤中修复此问题。

fun main() {
    val count: Int = 2
    println("You have count unread messages.")
}

2. 运行程序，输出应显示

You have count unread messages.

这句话没有意义！您希望在消息中显示count变量的值，而不是变量名。

3. 要修复输出，您需要一个字符串模板。这是一个字符串模板，因为它包含一个模板表达式，该表达式是美元符号（$）后跟变量名。模板表达式会被计算，其值会被替换到字符串中。

在count变量之前添加一个美元符号$。在本例中，模板表达式$count计算结果为2，并且2会替换到表达式所在字符串的位置。

fun main() {
    val count: Int = 2
    println("You have $count unread messages.")
}

4. 运行程序后，输出将与预期目标相符

You have 2 unread messages.

这句话对用户更有意义！

5. 现在将count变量的初始值更改为另一个整数字面量。例如，您可以选择数字10。保持程序中其余代码不变。

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

6. 运行程序。请注意，输出会相应更改，您甚至不需要更改程序中的println()语句。

You have 10 unread messages.

您可以看到字符串模板有多么有用。您只在代码中编写了一次字符串模板（"You have $count unread messages."）。如果您更改count变量的初始值，则println()语句仍然有效。您的代码现在更灵活了！

为了进一步强调这一点，请比较以下两个程序。第一个程序使用字符串字面量，其中字符串中直接包含未读消息的确切数量。当您的用户有 10 条未读消息时，此程序才有效。

fun main() {
    println("You have 10 unread messages.")
}

通过在第二个程序中使用变量和字符串模板，您的代码可以适应更多场景。此第二个程序更灵活！

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

类型推断

以下是一个提示，可以让您在声明变量时编写更少的代码。

类型推断是指 Kotlin 编译器可以推断（或确定）变量应该是什么数据类型，而无需在代码中显式编写类型。这意味着，如果您为变量提供初始值，则可以在变量声明中省略数据类型。Kotlin 编译器会查看初始值的数据类型，并假设您希望变量保存该类型的数据。

以下语法用于使用类型推断的变量声明

回到count示例，程序最初包含以下代码行

val count: Int = 2

但是，此代码行也可以写成如下所示。请注意，冒号符号（:）和Int数据类型被省略了。更新后的语法键入的单词更少，并且实现了创建名为count、值为2的Int变量的相同结果。

val count = 2

Kotlin 编译器知道您想将 2（一个整数）存储到变量 count 中，因此它可以推断出 count 变量的类型为 Int。很方便，对吧？这正是 Kotlin 代码编写更简洁的一个例子！

即使此示例仅讨论了 Int 类型的变量，类型推断的概念也适用于 Kotlin 中的所有数据类型。

整数的基本数学运算

值为 2 的 Int 变量与值为 "2" 的 String 变量有什么区别？当它们都打印到输出时，看起来是一样的。

将整数存储为 Int（而不是 String）的优势在于，您可以对 Int 变量执行数学运算，例如加法、减法、除法和乘法（请参阅其他 运算符）。例如，可以将两个整数变量加在一起以获取它们的和。当然，在某些情况下，将整数存储为字符串是合理的，但本节的目的是向您展示可以使用 Int 变量做什么。

1. 返回 Kotlin Playground 并删除代码编辑器中的所有代码。
2. 创建一个新程序，在其中为收件箱中未读电子邮件的数量定义一个整数变量，并将其初始化为例如 5 的值。如果您愿意，可以选择其他数字。为收件箱中已读电子邮件的数量定义第二个整数变量。将其初始化为例如 100 的值。如果您愿意，可以选择其他数字。然后通过将这两个整数加在一起打印出收件箱中的邮件总数。

fun main() {
    val unreadCount = 5
    val readCount = 100
    println("You have ${unreadCount + readCount} total messages in your inbox.")
}

3. 运行程序，它应该显示收件箱中的邮件总数

You have 105 total messages in your inbox.

对于字符串模板，您已经了解到可以在单个变量名前面加上 $ 符号。但是，如果您有更复杂的表达式，则必须将表达式括在花括号中，并在花括号前面加上 $ 符号：${unreadCount + readCount}。花括号内的表达式 unreadCount + readCount 计算结果为 105。然后将值 105 替换到字符串文字中。

4. 要进一步探讨此主题，请创建具有不同名称和不同初始值的变量，并使用模板表达式将消息打印到输出。

例如，修改您的程序以打印以下内容

100 photos
10 photos deleted
90 photos left

以下是一种编写程序的方法，尽管还有其他正确的方法可以编写它！

fun main() {
    val numberOfPhotos = 100
    val photosDeleted = 10
    println("$numberOfPhotos photos")
    println("$photosDeleted photos deleted")
    println("${numberOfPhotos - photosDeleted} photos left")
}

4. 更新变量

当应用程序正在运行时，可能需要更新变量的值。例如，在购物应用程序中，随着用户将商品添加到购物车，购物车总额会增加。

让我们将购物用例简化为一个简单的程序。下面的逻辑是用人类语言写成的，而不是用 Kotlin 写的。这称为伪代码，因为它描述了代码编写方式的关键要点，但没有包含代码的所有细节。

在程序的主函数中

• 创建一个初始值为 0 的整数 cartTotal 变量。
• 用户将一件价值 20 美元的毛衣添加到他们的购物车中。
• 将 cartTotal 变量更新为 20，这是他们购物车中商品的当前成本。
• 将购物车中商品的总成本（即 cartTotal 变量）打印到输出。

为了进一步简化代码，您无需编写用户将商品添加到购物车时的代码。（您还没有学习程序如何响应用户输入。这将在以后的单元中介绍。）因此，请专注于创建、更新和打印 cartTotal 变量的部分。

1. 将 Kotlin Playground 中的现有代码替换为以下程序。在程序的第 2 行，您将 cartTotal 变量初始化为值 0。由于您提供了初始值，因此由于类型推断，无需指定 Int 数据类型。在程序的第 3 行，您尝试使用赋值运算符（=）将 cartTotal 变量更新为 20。在程序的第 4 行，您使用字符串模板打印出 cartTotal 变量。

fun main() {
    val cartTotal = 0
    cartTotal = 20
    println("Total: $cartTotal")
}

2. 运行程序，您将收到编译错误。
3. 注意错误指出 val 无法重新赋值。错误出现在程序的第三行，该行尝试将 cartTotal 变量的值更改为 20. val cartTotal 在分配初始值（0）后，无法重新分配给另一个值（20）。

Val cannot be reassigned

如果需要更新变量的值，请使用 Kotlin 关键字 var 声明变量，而不是 val。

• val 关键字 - 当您预计变量值不会更改时使用。
• var 关键字 - 当您预计变量值可能会更改时使用。

使用 val，变量是只读的，这意味着您只能读取或访问变量的值。一旦设置了值，就不能编辑或修改它的值。使用 var，变量是可变的，这意味着可以更改或修改其值。值可以被改变。

为了记住区别，可以将 val 视为固定值，将 var 视为变量。在 Kotlin 中，建议尽可能使用 val 关键字而不是 var 关键字。

4. 更新程序第 2 行中 cartTotal 的变量声明，使用 var 而不是 val。代码应如下所示

fun main() {
    var cartTotal = 0
    cartTotal = 20
    println("Total: $cartTotal")
}

5. 注意程序第 3 行中更新变量的语法。

cartTotal = 20

使用赋值运算符（=）将新值（20）分配给现有变量（cartTotal）。您无需再次使用 var 关键字，因为变量已定义。

使用盒子类比，想象值 20 被存储在标记为 cartTotal 的盒子中。

以下是更新变量的一般语法的示意图，该变量已在代码的前面几行中声明。以要更新的变量的名称开头语句。添加一个空格、等号，然后是另一个空格。然后写出变量的更新值。

6. 运行您的程序，代码应该能够成功编译。它应该打印以下输出

Total: 20

7. 要查看变量值在程序运行期间如何变化，请在最初声明变量后将 cartTotal 变量打印到输出。请参阅以下代码更改。第 3 行有一个新的 println() 语句。代码的第 4 行还添加了一行空白行。空白行不会对编译器如何理解代码产生任何影响。在使代码更易于阅读（通过分隔相关的代码块）的位置添加空白行。

fun main() {
    var cartTotal = 0
    println("Total: $cartTotal")

    cartTotal = 20
    println("Total: $cartTotal")
}

8. 再次运行程序，输出应为

Total: 0
Total: 20

您可以看到，最初购物车的总额为 0。然后它更新为 20。您已成功更新了变量！这是因为您将 cartTotal 从只读变量（使用 val）更改为可变变量（使用 var）。

请记住，只有在您预计值会更改时才应使用 var 声明变量。否则，您应该默认使用 val 声明变量。此做法使您的代码更安全。使用 val 可以确保变量不会在程序中意外更新。一旦为 val 分配了值，它将始终保持该值。

增量和减量运算符

现在您知道必须将变量声明为 var 才能更新其值。将此知识应用于下面看起来应该很熟悉的电子邮件消息示例。

1. 将 Kotlin Playground 中的代码替换为此程序

fun main() {
    val count: Int = 10
    println("You have $count unread messages.")
}

2. 运行程序。它应该打印出

You have 10 unread messages.

3. 将 val 关键字替换为 var 关键字，以使 count 变量成为可变变量。当您运行程序时，输出不应该有任何变化。

fun main() {
    var count: Int = 10
    println("You have $count unread messages.")
}

4. 但是，现在您可以将count更新为不同的值。例如，当用户收件箱收到一封新邮件时，您可以将count增加 1。（您不需要编写接收邮件的代码。从互联网获取数据是稍后单元中更高级的主题。）目前，请关注使用这行代码将count变量增加1。

count = count + 1

等号右侧的表达式是count + 1，其计算结果为11。这是因为count的当前值为10（位于程序的第 2 行），并且10 + 1等于11。然后，使用赋值运算符，值11被赋值或存储到count变量中。

将此代码行添加到您程序的main()函数底部。您的代码应如下所示

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count = count + 1
}

如果您现在运行程序，输出将与之前相同，因为您还没有添加任何代码来在更新count变量后使用它。

5. 添加另一个打印语句，在变量更新后打印未读消息的数量。

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count = count + 1
    println("You have $count unread messages.")
}

6. 运行程序。第二个消息应显示更新后的count，即11条消息。

You have 10 unread messages.
You have 11 unread messages.

7. 简而言之，如果要将变量增加1，可以使用*增量运算符*（++），它由两个加号组成。通过在变量名后直接使用这些符号，您可以告诉编译器您希望将变量的当前值加 1，然后将新值存储到变量中。以下两行代码等效，但使用++增量运算符涉及较少的输入。

count = count + 1

count++

对您的代码进行此修改，然后运行您的程序。变量名和增量运算符之间不应有空格。

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count++
    println("You have $count unread messages.")
}

8. 运行程序。输出相同，但现在您了解了一个新运算符！

You have 10 unread messages.
You have 11 unread messages.

9. 现在修改程序的第 4 行，在count变量名后使用*减量运算符*（--）。减量运算符由两个减号组成。通过将减量运算符放在变量名之后，您可以告诉编译器您希望将变量的值减少1并将新值存储到变量中。

fun main() {
    var count = 10
    println("You have $count unread messages.")
    count--
    println("You have $count unread messages.")
}

10. 运行程序。它应该打印此输出

You have 10 unread messages.
You have 9 unread messages.

在本节中，您学习了如何使用增量运算符（++）和减量运算符（--）来更新可变变量。更具体地说，count++与count = count + 1相同，而count--与count = count - 1相同。

5. 探索其他数据类型

在代码实验室的前面，您了解了一些常见的基本数据类型：String、Int、Double和Boolean。您刚刚使用了Int数据类型，现在您将探索其他数据类型。

在 Kotlin Playground 中尝试这些程序，看看输出是什么。

双精度浮点数

当您需要一个带有小数值的变量时，请使用Double变量。要了解其有效范围，请参阅此表，并查看它可以存储的小数位数，例如。

假设您正在导航到目的地，并且您的行程分为三个单独的部分，因为您需要沿途停靠。此程序显示到达目的地的剩余总距离。

1. 在 Kotlin Playground 中输入此代码。您能理解每行代码在做什么吗？

fun main() {
    val trip1: Double = 3.20
    val trip2: Double = 4.10
    val trip3: Double = 1.72
    val totalTripLength: Double = 0.0
    println("$totalTripLength miles left to destination")
}

声明了三个名为trip1、trip2和trip3的变量来表示行程每个部分的距离。它们都是Double变量，因为它们存储小数。使用val声明每个变量，因为它们的值在程序执行过程中不会改变。程序还创建了一个名为totalTripLength的第四个变量，该变量当前初始化为0.0。程序的最后一行打印一条包含totalTripLength变量值的消息。

2. 修复代码，以便totalTripLength变量为所有三个行程长度的总和。

val totalTripLength: Double = trip1 + trip2 + trip3

等号右侧的表达式计算结果为9.02，因为3.20 + 4.10 + 1.72等于9.02。9.02的值被存储到totalTripLength变量中。

您的整个程序应如下所示

fun main() {
    val trip1: Double = 3.20
    val trip2: Double = 4.10
    val trip3: Double = 1.72
    val totalTripLength: Double = trip1 + trip2 + trip3
    println("$totalTripLength miles left to destination")
}

3. 运行程序。它应该打印出来

9.02 miles left to destination

4. 更新您的代码，由于类型推断，删除变量声明中不必要的Double数据类型。Kotlin 编译器可以根据作为初始值提供的小数推断出这些变量是Double数据类型。

fun main() {
    val trip1 = 3.20
    val trip2 = 4.10
    val trip3 = 1.72
    val totalTripLength = trip1 + trip2 + trip3
    println("$totalTripLength miles left to destination")
}

5. 再次运行您的代码以确保您的代码仍然可以编译。输出应该相同，但现在您的代码更简单了！

字符串

当您需要一个可以存储文本的变量时，请使用String变量。请记住，在字符串文字值周围使用引号，例如"Hello Kotlin"，而Int和Double文字值周围没有引号。

1. 将此程序复制并粘贴到 Kotlin Playground 中。

fun main() {
    val nextMeeting = "Next meeting:"
    val date = "January 1"
    val reminder = nextMeeting + date
    println(reminder)
}

请注意，声明了两个String变量，一个nextMeeting变量和一个date变量。然后声明了第三个名为reminder的String变量，将其设置为等于nextMeeting变量加上date变量。

使用+符号，您可以将两个字符串加在一起，这称为*连接*。这两个字符串组合在一起，一个接一个。表达式的结果nextMeeting + date是"Next meeting:January 1"，如下面的图所示。

然后，使用程序第 4 行的赋值运算符将值"Next meeting:January 1"存储到reminder变量中。

2. 运行您的程序。它应该打印出来

Next meeting:January 1

当您将两个字符串连接在一起时，字符串之间不会添加额外的空格。如果您希望在结果字符串中的冒号后添加空格，则需要将空格添加到一个字符串或另一个字符串中。

3. 更新您的nextMeeting变量，在结束引号之前在字符串末尾添加一个额外的空格。（或者，您可以在date变量的开头添加一个额外的空格）。您的程序应如下所示

fun main() {
    val nextMeeting = "Next meeting: "
    val date = "January 1"
    val reminder = nextMeeting + date
    println(reminder)
}

4. 再次运行您的程序，现在输出消息中的冒号后面应该有一个空格。

Next meeting: January 1

5. 修改代码，以便您连接 - 或添加 - 另一段文本到存储在reminder变量中的表达式中。

使用+符号将字符串文字" at work"添加到reminder字符串的末尾。

6. 运行程序。

它应该打印此输出

Next meeting: January 1 at work

下面的代码向您展示了一种可以实现此行为的方法。

fun main() {
    val nextMeeting = "Next meeting: "
    val date = "January 1"
    val reminder = nextMeeting + date + " at work"
    println(reminder)
}

请注意，nextMeeting和date周围没有引号，因为它们是现有字符串变量的名称（其中它们各自的值是带有引号的文本）。相反，文字" at work"之前未在任何变量中定义，因此请在该文本周围使用引号，以便编译器知道这是一个应连接到其他字符串的字符串。

从技术上讲，您可以通过声明一个包含完整文本的单个String变量来实现相同的输出，而不是使用单独的变量。但是，本练习的目的是演示如何声明和操作String变量，特别是如何连接单独的字符串。

7. 在读取包含字符串的代码时，您可能会遇到*转义序列*。转义序列是在其前面带有反斜杠符号（\）的字符，也称为转义反斜杠。

一个示例是在字符串文字中看到\"，如下面的示例所示。将此代码复制并粘贴到 Kotlin Playground 中。

fun main() {
    println("Say \"hello\"")
}

您之前学习过如何在字符串文字周围使用双引号。但是，如果您想在字符串中使用"符号怎么办？然后，您需要在字符串中的双引号前面添加反斜杠符号，如\"。请记住，整个字符串周围仍然应该有双引号。

8. 运行程序以查看输出。它应该显示

Say "hello"

在输出中，hello周围显示了引号，因为我们在println()语句中的hello之前和之后添加了\"。

有关 Kotlin 支持的其他转义序列，请参阅有关转义序列的文档页面。例如，如果要在字符串中添加换行符，请在字符 n 之前使用\符号，如\n所示。

现在您已经了解了连接字符串以及字符串中的转义序列。转到本代码实验室涵盖的最后一个数据类型。

布尔值

Boolean数据类型在您的变量只有两个可能的值（由true或false表示）时很有用。

例如，一个变量可以表示设备的飞行模式是打开还是关闭，或者应用程序的通知是启用还是禁用。

1. 在 Kotlin Playground 中输入此代码。在此程序的第 2 行，您声明了一个名为 notificationsEnabled 的 Boolean 变量，并将其初始化为 true。从技术上讲，您可以在声明中省略 : Boolean，因此如果需要，您可以将其删除。在程序的第 3 行，您打印出 notificationsEnabled 变量的值。

fun main() {
    val notificationsEnabled: Boolean = true
    println(notificationsEnabled)
}

运行程序，它应该打印出以下内容

true

2. 在程序的第 2 行将 Boolean 的初始值更改为 false。

fun main() {
    val notificationsEnabled: Boolean = false
    println(notificationsEnabled)
}

运行程序，它应该打印出以下内容

false

3. 其他数据类型可以与 Strings 连接。例如，您可以将 Booleans 连接到 Strings。使用 + 符号连接（或追加）notificationsEnabled 布尔变量的值到 "Are notifications enabled? " 字符串的末尾。

fun main() {
    val notificationsEnabled: Boolean = false
    println("Are notifications enabled? " + notificationsEnabled)
}

运行程序以查看连接的结果。程序应该打印出以下输出

Are notifications enabled? false

您可以看到可以将 Boolean 变量设置为 true 或 false 值。Boolean 变量使您能够编写更有趣的场景，在这些场景中，当 Boolean 变量具有 true 值时，您执行一组指令。或者，如果 Boolean 具有 false 值，则跳过这些指令。您将在未来的 codelab 中学习更多关于 Booleans 的知识。

6. 编码规范

在之前的 codelab 中，您了解了 Kotlin 样式指南，该指南用于以 Google 建议的方式编写 Android 代码，并为其他专业开发人员所遵循。

以下是一些基于您学习的新主题的格式和编码约定，供您遵循

• 变量名应使用驼峰命名法，并以小写字母开头。
• 在变量声明中，在指定数据类型时，冒号后应有一个空格。

• 在诸如赋值 (=)、加法 (+)、减法 (-)、乘法 (*)、除法 (/) 运算符等运算符之前和之后应有一个空格。

• 在编写更复杂的程序时，建议每行最多包含 100 个字符。这样可以确保您能够轻松地在计算机屏幕上阅读程序中的所有代码，而无需在阅读代码时水平滚动。

7. 代码注释

在编码时，另一个良好的实践是添加注释来描述代码的预期用途。注释可以帮助阅读您代码的人更轻松地理解它。两个正斜杠符号或 // 表示其后的行其余部分的文本被视为注释，因此不会被解释为代码。通常会在两个正斜杠符号后添加一个空格。

// This is a comment.

注释也可以从代码行的中间开始。在此示例中，height = 1 是一个正常的编码语句。// Assume the height is 1 to start with 被解释为注释，并且不被视为代码的一部分。

height = 1 // Assume the height is 1 to start with

如果您想使用超过 100 个字符的较长注释来详细描述代码，请使用多行注释。以正斜杠 (/) 和星号 (*) 开头，如 /*。在注释的每一行的开头添加一个星号。最后，以星号和正斜杠符号 */ 结束注释。

/*
 * This is a very long comment that can
 * take up multiple lines.
 */

此程序包含描述正在发生情况的单行和多行注释

/*
 * This program displays the number of messages
 * in the user's inbox.
 */
fun main() {
    // Create a variable for the number of unread messages.
    var count = 10
    println("You have $count unread messages.")

    // Decrease the number of messages by 1.
    count--
    println("You have $count unread messages.")
}

如前所述，您可以向代码中添加空白行以将相关的语句组合在一起，并使代码更易于阅读。

1. 在您之前使用的一个代码片段中添加一些注释。
2. 运行程序以确保行为没有改变，因为注释不应该影响输出。

8. 结论

工作出色！您学习了 Kotlin 中的变量，变量在编程中为什么有用，以及如何创建、更新和使用它们。您尝试了 Kotlin 中的不同基本数据类型，包括 Int、Double、String 和 Boolean 数据类型。您还了解了 val 和 var 关键字之间的区别。

所有这些概念都是您成为开发人员之旅中的关键基石。

我们将在下一个 codelab 中再见！

摘要

• 变量是用于存储单个数据片段的容器。
• 在使用变量之前，必须先声明它。
• 使用 val 关键字定义一个只读变量，其中值一旦分配就不能更改。
• 使用 var 关键字定义一个可变或可更改的变量。
• 在 Kotlin 中，建议尽可能使用 val 而不是 var。
• 要声明一个变量，请以 val 或 var 关键字开头。然后指定变量名、数据类型和初始值。例如：val count: Int = 2。
• 使用类型推断，如果提供了初始值，则省略变量声明中的数据类型。
• 一些常见的 Kotlin 基本数据类型包括：Int、String、Boolean、Float 和 Double。
• 使用赋值运算符 (=) 在变量声明期间或更新变量时为变量赋值。
• 您只能更新已声明为可变变量（使用 var）的变量。
• 使用增量运算符 (++) 或减量运算符 (--) 分别将整数变量的值增加或减少 1。
• 使用 + 符号将字符串连接在一起。您还可以将其他数据类型的变量（如 Int 和 Boolean）连接到 Strings。

了解更多信息

• 变量
• 基本类型
• 字符串模板
• 关键字和运算符
• 基本语法