跳到主要内容

Kotlin 变量和基本类型

提示
  1. 变量和声明方式：Kotlin 中使用 var 和 val 关键字声明变量，类型可由编译器推断或显式指定。
  2. var 与 val 区别：var 声明的变量可变，val 声明的变量不可变，类似于 Java 中的 final。
  3. 基本类型和数组：Kotlin 包含基本数据类型（数字、字符、布尔值）和数组，与 Java 有相似之处。

Here is an image that represents a Kotlin programming environment, featuring a laptop displaying Kotlin code, a Kotlin logo, and programming books in a study-like atmosphere.

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

为了标识存储区域，每个变量应该有一个唯一的名称（标识符）。

如何在 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      // 声明 String 类型的变量
... .. ...
language = "French"       // 变量初始化

val score: Int          // 声明 Int 类型的变量
... .. ...
score = 95             // 变量初始化

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

var language           // 错误
language = "French"

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

var language: String
language = 14         // 错误

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

var 和 val 的区别​

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

以下是一些示例：

var language = "French"
language = "German"

这里，language 变量被重新分配给了 German。由于变量是使用 var 声明的，这段代码完全有效。

val language = "French"
language = "German"      // 错误

在上面的示例中，你不能将 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] 范围内，可以使用 Byte 来替代 Int 或其他整数数据类型，以节省内存。
  • 示例：
fun main(args : Array<String>) {
    val range: Byte = 112
    println("$range")

    // 下面的代码会报错。为什么？
    // val range1: Byte = 200
}

当你运行这个程序时，输出将是：

112

2. Short​

  • Short 数据类型的值范围是 -32768 到 32767（16位有符号二进制补码整数）。
  • 如果确定变量的值将在 [-32768, 32767] 范围内，可以使用 Short 类型而不是其他整数数据类型来节省内存。
  • 示例：
fun main(args : Array<String>) {

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

运行程序时，输出将会是：

-11245

3. Int​

  • Int 数据类型的值范围是 -231 到 231-1（32位有符号二进制补码整数）。
  • 示例：
fun main(args : Array<String>) {

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

运行程序时，输出将会是：

100000

如果你为一个变量赋值一个介于 -231 到 231-1 之间的整数，而没有明确指定其类型，那么变量将会是 Int 类型。例如，

fun main(args : Array<String>) {

   // score 是 Int 类型
    val score = 10
    println("$score")
}

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

4. Long​

  • Long 数据类型的值范围是 -263 到 263-1（64位有符号二进制补码整数）。
  • 示例：
fun main(args : Array<String>) {

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

运行程序时，输出将会是：

9999

如果你为一个变量赋值一个大于 231-1 或小于 -231 的整数（而没有明确指定其类型），该变量将会是 Long 类型。例如，

val distance = 10000000000  // distance 变量是 Long 类型

同样，你可以使用大写字母 L 来指定变量是 Long 类型。例如，

val distance = 100L    // distance 变量是 Long 类型

5. Double​

  • Double 类型是双精度 64 位浮点数。
  • 示例：
fun main(args : Array<String>) {

    // distance 是 Double 类型
    val distance = 999.5
    println("$distance")
}

运行程序时，输出将会是：

999.5

Float​

fun main(args : Array<String>) {

    // distance 是 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
    // 从 Number 类型智能转换为 Int
    println("$test")

    test = 120L
    // 从 Number 类型智能转换为 Long
    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  // 错误

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 中的可空类型
最后于 更新