Kotlin 是强类型的语言,Kotlin 要求所有的变量必须先声明、后使用,声明变量时必须显示或隐式指定变量的类型(隐式的是指,声明的时候同时初始化,这样编译的时候就可以推断出该变量的类型了,Java 新版本也加了 var 关键字)。
声明变量使用 var、val 关键字,如下:
var | val 变量名 [:类型] [= 初始值]
和 Java 的不同之处是,变量类型写在变量名后面了,和 go 语言类似。
关键字有两个:
1、var:声明一个可变变量
2、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 的常量分为两种。
1、局部范围的常量:这种常量允许在声明时不指定初始值,只要在第一次使用之前指定初始值即可。
2、类的常量属性:这种常量属性既可以在声明时指定初始值,也可以在类或结构体的构造器中指定初始值。
需要指出的是,由于 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 位内存,范围 -263~263-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 整数数值三种表示方式:
1、十进制
2、二进制:以 0b 或 0B 开头的整数数值就是二进制的整数
3、十六进制:以 0x 或 0X 开头的整数数值就是十六进制的整数
浮点型
Kotlin 的浮点型有两种
1、Float:表示 32 位的浮点型,当精度要求不高时可以使用此种类型
2、Double:表示 64 位的双精度浮点型,当程序要求存储很大或者精度很高的浮点数时使用这种类型。
Kotlin 的浮点数有两种表示形式。
十进制数形式:这种形式就是简单的浮点数,例如 5.12、3.2 等。浮点数必须包含一个小数点,否则会被当成整型类型处理
科学计数形式:例如 5.12e2、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' 等
通过转义字符表示特殊字符型值,例如 ' '、' ' 等
直接使用 Unicode 值表示字符型值,格式是 'uXXXX',其中 XXXX 代表一个十六进制的整数。
与 Java 不同的是,Kotlin 的 Char 型变量不能当成整数值使用,Char 型变量或表达式不能赋值给整型变量,整型变量或表达式也不能赋值给 Char 型变量。简单来说,Kotlin 的 Char 型就是简简单单的字符型,不能直接当成整型使用。
// 直接指定单个字符作为字符值 val aChar: Char = 'a' // 使用转义字符来作为字符值 val enterChar: Char = ' ' // 使用 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 型值对应的字符编码进行减法运算。