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' 等
通過轉義字符表示特殊字符型值，例如 '\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 型值對應的字符編碼進行減法運算。