Kotlin 变量和基本类型

如你所知，变量是内存中的一个位置（存储区域）用于保存数据。

为了指示存储区域，每个变量都应该有一个唯一的名称（标识符）。了解更多关于如何在 Kotlin 中命名变量？

如何在 Kotlin 中声明变量？

要在 Kotlin 中声明变量，请使用 `var` 或 `val` 关键字。这是一个例子

var language = "French"
val score = 95

使用 `var` 和 `val` 的区别将在后面的文章中讨论。现在，让我们专注于变量声明。

在这里，`language` 是一个 `String` 类型的变量，`score` 是一个 `Int` 类型的变量。您不必指定变量的类型；Kotlin 会为您隐式完成。编译器通过初始化表达式知道这一点（在上面的程序中，“French”是 `String`，“95”是整数值）。这被称为编程中的类型推断。

但是，您可以根据需要显式指定类型

var language: String = "French"
val score: Int = 95

我们在上面的示例中声明时初始化了变量。但是，这不是必需的。您可以在一个语句中声明变量并指定其类型，然后在程序后面的另一个语句中初始化该变量。

var language: String      // variable declaration of type String
... .. ...
language = "French"       // variable initialization

val score: Int          // variable declaration of type Int 
... .. ...
score = 95             // variable initialization 

以下是一些会导致错误的示例。

var language           // Error 
language = "French"

在这里，没有显式指定 `language` 变量的类型，也没有在声明时初始化该变量。

var language: String
language = 14         // Error

​​​​在这里，我们正试图将 14（整数值）赋给不同类型（`String`）的变量。

var 和 val 之间的区别

• val（不可变引用）- 使用 `val` 关键字声明的变量在赋值后不能更改。它类似于Java 中的 final 变量。
• var（可变引用）- 使用 `var` 关键字声明的变量可以在程序稍后更改。它对应于常规 Java 变量。

以下是一些示例

var language = "French"
language = "German"     

在这里，`language` 变量被重新赋值为 `German`。由于该变量是使用 `var` 声明的，因此此代码可以完美运行。

val language = "French"
language = "German"      // Error

在上面的示例中，您不能将 `language` 变量重新赋值为 `German`，因为该变量是使用 `val` 声明的。

现在，您知道什么是 Kotlin 变量了，是时候学习 Kotlin 变量可以采用的不同值了。

Kotlin 基本类型

Kotlin 是一种像 Java 一样的静态类型语言。也就是说，变量的类型在编译时是已知的。例如，

val language: Int
val marks = 12.3

在这里，在编译时，编译器知道 `language` 是 `Int` 类型，`marks` 是 `Double` 类型。

Kotlin 中的内置类型可以分为：

• 数字
• 字符
• 布尔值
• 数组

数字类型

Kotlin 中的数字与 Java 相似。有 6 种内置类型表示数字。

• Byte
• Short
• Int
• Long
• Float
• Double

1. Byte

• `Byte` 数据类型的值可以是 -128 到 127（8 位有符号二进制补码整数）。
• 如果确定变量的值将在 [-128, 127] 范围内，则使用它而不是 `Int` 或其他整数数据类型来节省内存。
• 示例

  fun main(args : Array<String>) {
      val range: Byte = 112
      println("$range")
  
      // The code below gives error. Why?
      // val range1: Byte = 200
  }

运行程序后，输出将是

112

2. Short

• `Short` 数据类型的值可以是 -32768 到 32767（16 位有符号二进制补码整数）。
• 如果确定变量的值将在 [-32768, 32767] 范围内，则使用它而不是其他整数数据类型来节省内存。
• 示例

fun main(args : Array<String>) {

    val temperature: Short = -11245
    println("$temperature")
}

运行程序后，输出将是

-11245

3. Int

• `Int` 数据类型的值可以是 ` -2^31` 到 `2^31-1`（32 位有符号二进制补码整数）。
• 示例

fun main(args : Array<String>) {

    val score: Int =  100000
    println("$score")
}

运行程序后，输出将是

100000

如果您将介于 `-2^31` 和 `2^31-1` 之间的整数赋给一个变量而未明确指定其类型，则该变量将为 `Int` 类型。例如，

fun main(args : Array<String>) {

   // score is of type Int
    val score = 10
    println("$score")
}

如果您使用的是 IntelliJ IDEA，可以将光标放在变量内并按 `Ctrl + Shift + P` 来查看其类型。

4. Long

• `Long` 数据类型的值可以是 `-2^63` 到 `2^63-1`（64 位有符号二进制补码整数）。
• 示例

fun main(args : Array<String>) {

    val highestScore: Long = 9999
    println("$highestScore")
}

运行程序后，输出将是

9999

如果您将大于 `2^31-1` 或小于 `-2^31` 的整数值赋给一个变量（未明确指定其类型），则该变量将为 `Long` 类型。例如，

val distance = 10000000000  // distance variable of type Long

同样，您可以使用大写字母 `L` 来指定变量的类型为 `Long`。例如，

val distance = 100L    // distance value of type Long

5. Double

• Double 类型是双精度 64 位浮点数。
• 示例

fun main(args : Array<String>) {

    // distance is of type Double
    val distance = 999.5
    println("$distance")
}

运行程序后，输出将是

999.5

Float

• Float 数据类型是单精度 32 位浮点数。如果您感兴趣，请了解更多关于单精度和双精度浮点数。
• 示例

fun main(args : Array<String>) {

    // distance is of type Float
    val distance = 19.5F
    println("$distance")
}

运行程序后，输出将是

19.5

请注意，我们在上面的程序中使用了 `19.5F` 而不是 `19.5`。这是因为 `19.5` 是一个 `Double` 字面量，您不能将 `Double` 值赋给 `Float` 类型的变量。

要告诉编译器将 `19.5` 视为 `Float`，您需要在末尾加上 `F`。

如果您不确定程序中的变量将分配什么数字值，您可以将其指定为 `Number` 类型。这允许您将整数和浮点值赋给变量（一次一个）。例如，

fun main(args : Array<String>) {

    var test: Number = 12.2
    println("$test")

    test = 12
    // Int smart cast from Number
    println("$test")

    test = 120L
    // Long smart cast from Number
    println("$test")
}

运行程序后，输出将是

12.2
12
120

要了解更多，请访问：Kotlin 智能转换

Char

要表示 Kotlin 中的字符，使用 `Char` 类型。

与 Java 不同，`Char` 类型不能被视为数字。访问此页面以了解更多关于Java char 类型的信息。

fun main(args : Array<String>) {

    val letter: Char
    letter = 'k'
    println("$letter")
}

运行程序后，输出将是

k

在 Java 中，您可以执行类似的操作

char letter = 65;

但是，以下代码在 Kotlin 中会产生错误。

var letter: Char = 65  // Error

Boolean

• Boolean 数据类型有两个可能的值，即 `true` 或 `false`。
• 示例

fun main(args : Array<String>) {

    val flag = true
    println("$flag")
}

布尔值用于决策制定语句（稍后章节将讨论）。

Kotlin 数组

数组是包含单个类型数据（值）的容器。例如，您可以创建一个可以保存 100 个 `Int` 类型值的数组。

在 Kotlin 中，数组由 `Array` 类表示。该类具有 `get` 和 `set` 函数，`size` 属性以及一些其他有用的成员函数。

要详细了解数组，请访问：Kotlin 数组

Kotlin 字符串

在 Kotlin 中，字符串由 `String` 类表示。字符串字面量（如“this is a string”）被实现为该类的实例。

要详细了解字符串，请访问：Kotlin 字符串

推荐阅读

• Kotlin 中的类型转换
• Kotlin 中的智能转换
• Kotlin 可空类型