Kotlin Tutorial（4）基本型態與變數 by Michael | CodeData
top
技術文章 / Kotlin

Kotlin Tutorial（4）基本型態與變數

分享：
閲讀次數：13789 發表時間：2017/06/22
tags: kotlin variable

Kotlin Tutorial（3）Kotlin程式設計基礎 << 前情

變數的宣告與使用

變數是所有程式設計語言最基礎的主題，學習一種新的程式語言，在寫了Hello World程式後，接下來要認識與掌握變數的宣告與使用。以下面這個程式來說，使用顯示訊息函式與String template，執行後在畫面上顯示簡單的自我介紹，裡面也包含一般的數學運算：

/* net.macdidi5.kotlin.tutorial.ch04.HelloSimon.kt */

package net.macdidi5.kotlin.tutorial.ch04

fun main(args: Array<String>) {
    println("Hello! I am Simon.")
    println("I am ${35} years old.")
    println("I am ${35 * 12} months old.")
    println("I am ${35 * 365} days old.")
}

上面的程式執行後在畫面顯示：

Hello! I am Simon.
I am 35 years old.
I am 420 months old.
I am 12775 days old.

上面的程式碼雖然簡單，不過如果想要把年齡換成36歲，你會發現需要更改所有年齡的數字，這樣的作法麻煩又容易出錯。同樣的需求如果使用變數話：

/* net.macdidi5.kotlin.tutorial.ch04.HelloSimon2.kt */

package net.macdidi5.kotlin.tutorial.ch04

fun main(args: Array<String>) {
    // 宣告一個名稱為age的整數變數
    val age : Int = 35

    println("Hello! I am Simon.")
    // 使用變數顯示與計算
    // 如果只是單純的變數，可以省略{}，只剩下$就可以了
    println("I am $age years old.")
    // 如果是運算式，就一定要使用{}
    println("I am ${age * 12} months old.")
    println("I am ${age * 365} days old.")
}

上面程式執行後的結果是一樣的，不過想要把年齡換成36歲，只要修改變數值就可以了：

// 把age的變數值改為36，後面就不用修改了
val age : Int = 36

Kotlin基本型態

Kotlin跟Java還有其它程式設計語言類似，針對一般應用程式常用的資料，定義這些基本型態：

  • Byte：8位元整數（-128 ~ 127）
  • Short：16位元整數（-32768 ~ 32767）
  • Int：32位元整數（-2147483648 ~ 2147483647）
  • Long：64位元整數（-9223372036854775808 ~ 9223372036854775807）
  • Float：32位元浮點數（1.4E-45 ~ 3.4028235E38）
  • Double：64位元浮點數（4.9E-324 ~ 1.7976931348623157E308）
  • Char：字元
  • Boolean：邏輯
  • String：字串

如果變數在設定值以後，就不會改變它的值，使用下面的語法宣告不可改變值的變數：

val 變數名稱: 型態 ＝ 初始值

如果變數在設定值以後，還會改變它的值，使用下面的語法宣告可以改變值的變數：

var 變數名稱: 型態 ＝ 初始值

兩個的差異在宣告變數的關鍵字，val（value）宣告不可改變值的變數，var（variable）宣告可以改變值的變數。

數值

Byte、Short、Int、Long、Float與Double，是Kotlin定義的數值型態，它們可以指定與保存下列的數值資料：

  • 整數（Byte、Short、Int）：沒有小數的數字
    • 十進位：十進位，例如：35、128、650813
    • 十六進位：十六進位，以「0x」或「0X」開始，使用大寫或小寫的A到F表示10到15，例如：0x0F、0X128、0xa0b1c2
    • 二進位：二進位，以「0b」或「0B」開始，例如：0b10100001、0B1010
  • 整數（Long）：沒有小數的數字，可以使用十、十六與二進位，在數值最後面加上大寫L或小寫l，使用64位元的儲存空間
  • 浮點數：有小數的數字
    • 雙精確度（Double）：例如，6508.13，或是使用科學表示法，例如：6.50813e10、1.23E12
    • 單精確度（Float）：在數值最後面加上大寫F或小寫f，例如，6508.13F，或是使用科學表示法，例如：6.50813e10f、1.23E12F

宣告變數的時候，可以依照資料的種類明確的設定型態。如果在宣告變數的時候也設定一個值，就可以省略型態，Kotlin會根據值的型態自動宣告：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric.kt */

val v: Byte = 35        // 宣告Int型態的變數並指定為35
val v2: Byte = 128      // 錯誤！指定的數值超過Byte型態範圍

val v3: Int = 35        // 宣告Int型態的變數並指定為35
val v4 = 35             // 經由設定值35，自動宣告變數的型態為Int
                        // 整數數值預設的型態為Int

val v5: Int             // 宣告變數的時候如果沒有設定值，就一定要設定型態
v5 = 35                 // 第一次設定值
v5 = 36                 // 錯誤！

var v6: Int = 35        // 使用var宣告變數
v6 = 36                 // 可以改變

為了讓數值看起來比較清楚，可以自己在需要的地方加上底線。底線並沒有實際的作用，編譯程式的時候就會忽略：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric02.kt */

val v = 1_000_000               // 十進位整數數值使用底線
val v2 = 12_34.56_71_23         // 十進位小數數值使用底線
val v3 = 0b1010_0000_1111_0101  // 二進位整數數值使用底線

val v4 = _1234_._567123_        // 錯誤！底線加在不需要的地方

設定值的時候要特別注意不同型態的範圍：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric03.kt */

val v:  Int = 35            // 正確
val v2: Int = 2147483648    // 錯誤！數值已經超過Int型態的範圍

val v3: Long = 2147483648   // 正確
val v4: Long = 2147483648L  // 正確，可以在數值後面加上L
val v5: Int = 3.14          // 錯誤！不可以指定小數數值

不同型態的變數，不可以互相指定，否則會發生編譯錯誤：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric04.kt */

var v: Int = 3;
var v2: Byte = 3;
v2 = v              // 錯誤！指定Byte給Int

需要指定不同型態的變數，Byte、Short、Int、Long、Float與Double型態的變數與值，都可以使用下面的數值轉換函式，

  • toByte(): Byte
  • toShort(): Short
  • toInt(): Int
  • toLong(): Long
  • toFloat(): Float
  • toDouble(): Double
  • toChar(): Char

指定不同型態變數的時候，需要使用上面的數值轉換函式，轉換成對應的型態，例如下面的程式片段：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric05.kt */
var vInt: Int = 3
var vByte: Byte = 3

vInt = vByte.toInt()              // 呼叫toInt()函式把Byte轉換為Int
vByte = vInt.toByte()             // 呼叫toByte()函式把Int轉換為Byte

轉換型態的時候，可能會發生下面的情況：

/* net.macdidi5.kotlin.tutorial.ch04.HelloNumeric06.kt */

var v3: Double = 3.14
var v4 = v3.toInt()
println(v4)                  // 顯示3，轉換成整數後會捨去小數

var v5: Int = 321
var v6: Byte = v5.toByte()
println(v6)                  // 顯示65，轉換的數值超過Byte範圍

Int型態的321，二進位是「0000_0000_0000_0000_0000_0001_0100_0001」，轉換成Byte型態以後，只剩下最後面的8位元「0100_0001」，換算成十進位是65。

字元

應用程式的資料只需要用一個字元來表示的時候，就會用到字元。例如性別，你會用「M」和「F」，或是「男」和「女」。字元值的前後必須使用單引號。下面是一般字元與特殊字元的範例：

  • 一般字元：'A'、'中'
  • 特殊字元：
    • '\t'：tab
    • '\b'：backspace
    • '\n'：換行（new line）
    • '\r'：歸位（return）
    • '\''：單引號（single quart）
    • '"'：雙引號（double quart）
    • '\'：backslash
    • '$'：錢號（dollar sign）
  • 使用Unicode編碼：'\uFFFF'、'\u0032'

Char型態的字元採用Unicode編碼，需要的時候也可以使用轉換函式。下面的程式片段示範Char型態變數的宣告與使用:

/* net.macdidi5.kotlin.tutorial.ch04.HelloChar.kt */

val gender: Char = 'M'
val gender2 = 'F'                   // 省略型態

val genderCode = gender.toInt()     // 從Char轉換為Int
val gender2Code = gender2.toInt()   // 從Char轉換為Int

println("gender: $gender, genderCode: $genderCode")
// 顯示： gender: M, genderCode: 77

println("gender2: $gender2, gender2Code: $gender2Code")
// 顯示： gender2: F, gender2Code: 70

val gender3 = 70.toChar()           // 從Int轉換為Char
println("gender3: $gender3")
// 顯示： gender3: F

特殊字元包含控制字元（例如換行'\n'）與跳脫字元（例如'\'）。控制字元可以方便執行訊息文字格式的控制，跳脫字元用來處理特殊的字元：

/* net.macdidi5.kotlin.tutorial.ch04.HelloChar02.kt */

var message = "This is\na book."       // 使用\n
println(message)
// 顯示兩行訊息：
// This is
// a book.

var s  = "Double quote(") in string"   // 錯誤
var s2 = "Double quote(\") in string"  // 使用\"
var s3 = "Dollar sign(\$) in string"
// $在字串裡面為使用String template，如果需要顯示$，就必須使用\$

邏輯

Boolean型態用來表示某種狀態，而且它的狀態只有兩種，例如門的開或關。邏輯值只有「true」與「false」兩種。使用下面的語法宣告Boolean型態變數：

val|var 變數名稱: Boolean ＝ true|false

下面的程式片段示範宣告Boolean型態變數：

/* net.macdidi5.kotlin.tutorial.ch04.HelloBoolean.kt */

val update: Boolean = true
var isRainy = false

在應用程式需要執行判斷與選擇的時候，例如年齡是否滿20歲，你需要把的判斷條件使用關聯與條件運算子結合起來，這些運算子執行後的結果是Boolean型態，只有「true」和「false」兩種。下面是執行基本判斷的運算子：

  • ==、!=： 相等、不相等
  • >、<：大於、小於
  • >=、<=：大於等於、小於等於

下面是結合多個判斷條件的運算子：

  • &&：而且，全部條件都為true的話，結果為true
  • ||：或，任何一個條件為true的話，結果為true
  • !：否定，條件為true結果為false，條件為false結果為true

下面的程式片段示範執行判斷的運算式：

/* net.macdidi5.kotlin.tutorial.ch04.HelloBoolean02.kt */

val age = 35
val gender = 'M'

val result = age > 20
val result2 = !(age > 20)
println("result: $result, result2: $result2")
// 顯示： result: true, result2: false

val result3 = age > 20 && gender == 'M'
val result4 = age > 50 || gender == 'F'
println("result3: $result3, result4: $result4")
// 顯示： result3: true, result4: false

字串

應用程式經常需要儲存與使用字串型態的資料，例如姓名或地址。字串的型態是「String」，字串值前後必須使用雙引號，裡面可以包含控制字元與跳脫字元。下面的程式片段示範宣告與使用字串變數：

/* net.macdidi5.kotlin.tutorial.ch04.HelloString.kt */

val name: String = "Simon Johnson"
val address = "Earth\nSolar system"

println(name)               // 顯示： Simon Johnson
println(address)
// 顯示兩行訊息：
// Earth
// Solar system

val information = name + "\n" + address
println(information)
// 顯示三行訊息：
// Simon Johnson
// Earth
// Solar system

需要比較兩個字串是否一樣，使用「==」運算子。字串也可以比較大小，以英文字母來說，'Z'會比'A'大：

/* net.macdidi5.kotlin.tutorial.ch04.HelloString02.kt */

val place = "earth"
val place2 = "earth"
val place3 = "Earth"

println(place == place2)        // 顯示： true
println(place == place3)        // 顯示： false

println( "A" > "Z" )            // 顯示： false
println( "Simon" > "Mary" )     // 顯示： true

String可以使用在前面說明過的轉換函式，把字串轉換為數值或邏輯值：

/* net.macdidi5.kotlin.tutorial.ch04.HelloString03.kt */

val s = "123"
val i = s.toInt()               // 從String轉換為Int

val s2 = "123.321"
val i2 = s2.toDouble()          // 從String轉換為Double

val b = "true".toBoolean()      // 大寫或小寫的"true"都會轉換成true
val b2 = "false".toBoolean()    // 其它的字串值都會轉換成false
val b3 = "hello".toBoolean()    // "hello"轉換成false

val s3 = "hello"
val i3 = s3.toInt()     // 錯誤！程式中斷，產生NumberFormatException

字串有很多其它的應用，會在後面的內容詳細說明。

數學運算

應用程式在宣告一些數值變數後，通常會執行一些需要的運算，例如+（加）、-（減）、*（乘）、/（除）和%（餘數）。運算時要特別注意計算結果的型態：

/* net.macdidi5.kotlin.tutorial.ch04.HelloArithmetic.kt */

var vByte: Byte = 1
var vByte2: Byte =  2
var vByte3: Byte = vByte + vByte2   // 錯誤！
// 雖然是兩個Byte變數執行運算，不過計算結果為Int

不同型態的變數在執行數學運算以後，計算的結果預設為Int，如果執行計算的數值或變數型態範圍大於Int的話，計算的結果會是最大的型態：

/* net.macdidi5.kotlin.tutorial.ch04.HelloArithmetic02.kt */

// 從Byte到Double共六個不同數值型態的變數
var vByte: Byte = 1
var vShort: Short =  2
var vInt: Int = 3
var vLong: Long = 4L
var vFloat: Float = 5.1F
var vDouble: Double = 6.2

var r: Int = vByte + vShort + vInt  // 計算結果為Int

var r2: Int = vByte + vLong         // 錯誤！計算結果為Long

var r3: Long = vByte + vLong        // 計算結果為Long
var r4 = vByte + vLong              // 變數r4的型態為Long

var r5: Float = vInt + vDouble      // 錯誤！計算結果為Double

var r6: Double = vInt + vDouble     // 計算結果為Double
var r7 = vInt + vDouble             // 變數r7的型態為Double
var r8 = vFloat + vDouble           // 變數r8的型態為Double

下一步

瞭解基本型態變數的宣告與使用以後，接下來繼續討論字串型態變數的進階應用，還有Kotlin在變數許多加強的特性，讓你可以完全掌握變數的應用。

相關的檔案都可以在GitHub瀏覽與下載。

http://github.com/macdidi5/Kotlin-Tutorial

後續 >> Kotlin Tutorial（5）決策與判斷

分享：
按讚！加入 CodeData Facebook 粉絲群

相關文章

留言

留言請先。還沒帳號註冊也可以使用Facebook、Google+登錄留言

關於作者

Michael

Email Facebook Twitter GitHub Linkedin

張益裕。目前是恆逸教育訓練中心講師、資訊圖書與專欄作者。涵蓋的領域有OOAD、Java EE、JavaFX、Java Embedded、Android與SQL。

熱門論壇文章

熱門技術文章