kotlin 变量声明

Kotlin 是强类型的语言，Kotlin 要求全部的变量必须先声明、后使用，声明变量时必须显示或隐式指定变量的类型（隐式的是指，声明的时候同时初始化，这样编译的时候就能够推断出该变量的类型了，Java 新版本也加了 var 关键字）。

 

声明变量使用 var、val 关键字，以下：

var | val 变量名 [:类型] [= 初始值]

　和 Java 的不一样之处是，变量类型写在变量名后面了，和 go 语言相似。

 

关键字有两个：

一、var：声明一个可变变量

二、val：声明一个不可变变量（这里的不可变只是指只能赋值一次，这个赋值的过程能够发生在变量声明的时候，或者声明以后，赋值以后就不能再修改其值）

 

在上面的语法中，要么经过 ":类型" 的形式显示指定该变量的类型，要么为该变量指定初始值 -- Kotlin 编译器将会根据该初始值肯定变量的类型，不能声明变量时既不指定变量类型，也不指定初始值。

可是咱们也能够同时指定类型和指定初始值，可是这时候的变量类型必需要和初始化类型推断的类型同样。

 

例子：

fun main(args: Array<String>) {
    // 声明变量时同时指定类型和初始值
    var a :Int = 5
    val a1 :Int = 5
    
    // 声明变量指定类型，不指定初始值
    var b :Int
    b = 6
    val b1: Int
    b1 = 6
    // b1 = 8 // 错误，val 变量不能重复赋值
    
    // 声明类型不指定类型，类型由类型推断得出
    var c = 7
    val c1 = 7
}

　　

使用 val 声明的不可变变量其实至关于常量，这意味着它的值一旦被初始化以后，将不能够被从新赋值。根据产量所在的位置不一样，Kotlin 的常量分为两种。

一、局部范围的常量：这种常量容许在声明时不指定初始值，只要在第一次使用以前指定初始值便可。

二、类的常量属性：这种常量属性既能够在声明时指定初始值，也能够在类或结构体的构造器中指定初始值。

 

须要指出的是，因为 Kotlin 程序编译的字节码必须遵照 JVM 规范，所以，若是直接在 Kotlin 程序中定义变量、函数，kotlinc 将会自动生成一个名为 “文件名首字母大写+Kt” 的类，并将变量转换为该类的静态的 getter、setter 方法（其中 val 声明的只有 getter 方法），函数则转换为该类的静态方法。

 

还有一点须要说明的是，因为 kotlinc 会为包含函数、变量的 Kotlin 程序生成额外的类，这就要求不能在该包下重复定义同名的类。例如，咱们定义了一个名为 liang.kt 的Kotlin 程序，且该程序中包含了函数或变量，那么 kotlinc 会自动生成 LiangKt 类，所以就不能在该包下重复定义 LiangKt 类。

 

 

整型

与 Java 相似，Kotlin 也提供了 4 种整型。

Byte：占 8 位内存，范围 -128~127。兼容 Java 的 byte 和 Byte 类型。

Short：占 16 位内存，范围 -32768~32767。兼容 Java 的 short 和 Short 类型。

Int：占 32 位内存，范围 -2147483648~2147483647。兼容 Java 的 int 和 Integer 类型。

Long：占 64 位内存，范围 -2⁶³~2⁶³-1。兼容 Java 的 long 和 Long 类型。

因为 Int 型是 Kotlin 最经常使用的整数类型，所以，若是声明一个常量或变量时没有指定数据类型，只是简单地指定了其初始值为整型，那么 Kotlin 会自动判断该变量的类型为 Int。

 

Kotlin 的整型与 Java 不一样，Kotlin 的整型不是基本类型，而是引用类型（大体至关于 Java 的包装类），Byte、Short、Int、Long 都继承了 Number 类型，所以它们均可调用方法、访问属性。

 

有一点须要提早说明的是，Kotlin 是 null 安全的语言，所以 Byte、Short、Int、Long 类型变量都不能接受 null 值，若是要存储 null 值，则应该使用 Byte?、Short?、Int?、Long? 类型。如：

// Int 类型变量不支持 null 值，因此下面的代码是错误的
var notNull: Int = null
// Int? 至关于支持 null 值的 Int 型，因此下面代码是正确的
var nullable: Int? = null

　　

因而可知，Kotlin 语言容许在已有数据类型后面添加“?”，添加 “?” 后的数据类型至关于对原有类型进行了扩展，带 “?” 的数据类型可支持被赋予 null 值。

 

此外，整数类型添加 “?” 后缀与不添加还有一个区别 -- 普通类型的整型变量将会被映射成 Java 的基本类型；带 “?” 后缀的整型变量将会映射成基本类型的包装类。如；

var pm1: Int = 200 // pm1 的类型是 Java 的 int 类型
var pm2: Int = 200 // pm2 的类型是 Java 的 int 类型
println(pm1 === pm2) // 基本类型比较，输出 true

var obj1: Int? = 200 // pm1 的类型是 Java 的 Integer 类型
var obj2: Int? = 200 // pm2 的类型是 Java 的 Integer 类型
println(obj1 === obj2) // 引用类型比较，输出 false

　　

Kotlin 整数数值三种表示方式：

一、十进制

二、二进制：以 0b 或 0B 开头的整数数值就是二进制的整数

三、十六进制：以 0x 或 0X 开头的整数数值就是十六进制的整数

 

浮点型

Kotlin 的浮点型有两种

一、Float：表示 32 位的浮点型，当精度要求不高时可使用此种类型

二、Double：表示 64 位的双精度浮点型，当程序要求存储很大或者精度很高的浮点数时使用这种类型。

 

Kotlin 的浮点数有两种表示形式。

十进制数形式：这种形式就是简单的浮点数，例如 5.十二、3.2 等。浮点数必须包含一个小数点，不然会被当成整型类型处理

科学计数形式：例如 5.12e二、5.12E2 等。

须要指出的是，只有浮点型的数值才可使用科学计数形式表示。

 

若是声明一个常量或变量没有指定数据类型，只是指定其初始值为浮点数，那么 Kotlin 会自动判断该变量的类型为 Double。

 

除此以外，Kotlin 还提供了 3 个特殊的浮点型数值：正无穷大、负无穷大 和 非数。例如，使用一个正数除以 0.0 将获得正无穷大数值，使用一个负数除以 0.0 将获得负无穷大数值， 0.0 除以 0.0 或 对负数开方将获得一个非数。

须要指出的是，全部的正无穷大数值都相等，全部的负无穷大数值都相等；而非数不与任何数值相等，甚至和非数本身都不相等。

 

var af1 = 5.2345556f
// 下面将看到 af1 的值已经发生了改变
println("af1 的值为:${af1}")

// 声明 af2 是 Float 类型，但 25.2345 默认是 Double 类型，所以下面代码编译时报错
var af2: Float = 23.2345

// f1 的类型被推断为 Double
var f1 = 5.12e2
println("f1 的值为: ${f1}")

var a = 0.0

// 5.0 除以 0.0 将出现无穷大数值
println("5.0 / a 的值为: ${5.0 / a}")
// 全部的正无穷大数值都相等, 因此下面将会输出 true
println(5.0 / a == 5000 / 0.0)

// -5.0 除以 0.0 将出现负无穷大数值
println("-5.0 / a 的值为: ${-5.0 / a}")
// 全部的负无穷大数值都相等，因此下面将会输出 true
println(-5.0 / a == -5000 / 0.0)

// 0.0 除以 0.0 将出现非数
var nan: Double = a / a
println("a/a 的值为: ${nan}")

// 非数与本身都不相等, 因此下面将会输出 false
println(nan == nan)

　　

 

字符型

字符型一般用于表示单个的字符，字符型值必须使用单引号（'）括起来。Kotlin 语言使用 16 位 Unicode 字符集做为编码方式，而 Unicode 被设计成支持世界上全部书面语言的字符，包括中文字符，所以 Kotlin 程序支持各类语言的字符。

 

字符型值有以下 3 种表示形式：

直接经过单个字符来指定字符型值，例如 'A'、'9' 等

经过转义字符表示特殊字符型值，例如 '\n'、'\t' 等

直接使用 Unicode 值表示字符型值，格式是 '\uXXXX'，其中 XXXX 表明一个十六进制的整数。

 

与 Java 不一样的是，Kotlin 的 Char 型变量不能当成整数值使用，Char 型变量或表达式不能赋值给整型变量，整型变量或表达式也不能赋值给 Char 型变量。简单来讲，Kotlin 的 Char 型就是简简单单的字符型，不能直接当成整型使用。

 

// 直接指定单个字符做为字符值
val aChar: Char = 'a'
// 使用转义字符来做为字符值
val enterChar: Char = '\r'
// 使用 Unicode 编码值来指定字符值
val ch: Char = '\u9999'
// 将输出一个 '香' 字符
println(ch)
// 定义一个 '疯' 字符值
var feng: Char = '疯'
// 将 Char 型变量当成 Int 型处理会报错
var fengValue: Int = feng

　　

 

数值型之间的类型转换

Kotlin 是一门强类型的语言，所以 Kotlin 不一样类型的值常常须要进行相互转换，数值型之间的变量和值也能够相互转换。

 

整型之间的转换

Kotlin 与 Java 不一样，Kotlin 不支持取值范围小的数据类型隐式转换为取值范围大的类型。

因为不一样整型类型支持的数值范围存在差别，所以进行类型转换时必须注意选择合适的类型。Kotlin 为全部数值类型都提供了以下方法进行转换。

toByte()：转换为 Byte 类型

toShort()：转换为 Short 类型

toInt()：转换为 Int 类型

toLong()：转换为 Long 类型

toFloat(): 转换为 Float 类型

toDouble(): 转换为 Double 类型

toChar(): 转换为 Char 类型

Kotlin 要求不一样整型的变量或值之间必须进行显式转换。

 

var bookPrice : Byte = 79
var itemPrice : Short = 120
// bookPrice 是 Byte 类型，但变量 a 是 Short 类型，所以下面代码错误
// var a: Short = bookPrice
//显式将 bookPrice 强制转换为 Short 类型
var a : Short = bookPrice.toShort()
var b : Byte = itemPrice.toByte()
println("a: $a, b: $b")
val amount = 233
// 将 Int 型变量转换为 Byte 类型，发生溢出
val byteAmount : Byte = amount.toByte()
println(byteAmount)

　　

虽然 Kotlin 缺少隐式转换，但 Kotlin 在表达式中能够自动转换，这种转换是基于上下文推断出来的，并且算术运算会有重载作适当转换。

例如：

// 算术表达式中的 bookPrice、itemPrice 会自动提高为 Int 类型
var total = bookPrice + itemPrice
println("total的值为: $total")
// 能够看到 total 映射的 Java 类型为 Int
println("total的类型为: ${total.javaClass}")

// 下面表达式中的 bookPrice 强制转换为 Long 类型，所以整个表达式类型为 Long
var tot = bookPrice.toLong() + itemPrice.toByte()
println("total的值为: $tot")
// 能够看到 tot 映射的 Java 类型为 long
println("total的类型为: ${tot.javaClass}")

　　

上面的程序中使用了变量的 javaClass 属性，该属性来自 Any 类型（Any 类型是 Kotlin 中全部类型的根父类），javaClass 属性用于获取指定变量对应的 Java 类型（大体至关于 Java 反射中的 getClass() 方法 ）

 

Kotlin 虽然不容许直接将 Char 型值当成整数使用，也不容许将整数值直接当成 Char 型值使用，但 Kotlin 依然可调用数值型的 toChar() 方法将数值型的 toChar() 方法将数值型变量或表达式转换为 Char 类型。例如，下面的程序展现了如何生成一个 6 位的随机字符串。

// 定义一个空字符串
var result = ""
// 进行 6 次循环
for (i in 0..5) {
    // 生成一个 97~122 之间的 Int 类型整数
    val intVal = (Math.random() * 26 + 97).toInt()
    // 将 intVal 强制转换为 Char 类型后链接到 result 后面
    result += intVal.toChar()
}
println(result)

　　

此外，虽然 Char 型值不能被当成整数进行算术运算，但 Kotlin 为 Char 类型提供了加、减 运算支持，其计算规则以下。

Char 型值加、减一个整型值：Kotlin 会先将该 Char 型值对应的字符编码进行加、减该整数，而后将计算结果转换为 Char 型值。

两个 Char 型值进行相减：Kotlin 将两个 Char 型值对应的字符编码进行减法运算。