在 Kotlin 中创建和使用变量

1. 开始之前

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

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

另一方面，如果您查看新闻应用程序，文章会经常更改。文章名称、来源、发布时间和图像都会发生变化。

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

在本 Codelab 中，您将学习如何编写使用变量的代码，以便程序的某些部分可以更改，而无需编写一整套新的指令。您将像在之前的 Codelab 中一样使用 Kotlin Playground。

您将构建什么

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

您将学到什么

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

您需要什么

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

2. 变量和数据类型

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

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

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

亲爱的 Lauren：

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

祝您有美好的一天！

这封信很好，但它仅适用于您与 Lauren 的特定情况。如果您发现自己多次编写相同的信件，但针对不同的人稍作修改怎么办？创建单个信件模板会更有效，在可更改的部分留空。

亲爱的 ____ ：

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

祝您有美好的一天！

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

亲爱的 {name} ：

今天在 {location} 见到您真是太好了。我期待着在 {date} 见到您。

祝您有美好的一天！

从概念上讲，构建应用程序类似。您有一些数据的占位符，而应用程序的其他部分保持不变。

在上面新闻应用程序的示例中，“欢迎”文本、“为您提供的最新新闻”标题和“查看更多文章”按钮文本始终保持不变。相反，用户姓名和每篇文章的内容会发生变化，因此这是一个使用变量来保存每条信息的好机会。

您不希望编写应用程序中的代码（或指令）仅适用于名为 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. 探索其他数据类型

在 Codelab 的前面，你已经了解了一些常见的基本数据类型：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。

现在你已经学习了如何连接字符串以及字符串中的转义序列。继续学习本代码实验室涵盖的最后一个数据类型。

布尔值

当你的变量只有两个可能的用 true 或 false 表示的值时，Boolean 数据类型非常有用。

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

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 值，则跳过这些指令。你将在以后的代码实验室中学习更多关于 Booleans 的知识。

6. 编码规范

在之前的代码实验室中，你已经了解了 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 关键字之间的区别。

所有这些概念都是你成为开发人员之旅中的关键构建块。

下一节代码实验室再见！

总结

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

了解更多

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