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 型值對應的字符編碼進行減法運算。