Kotlin---基礎數據類型與函數

變量與常量

Kotlin和一些腳本語言一樣，在定義變量的時候不需要指定變量類型，Kotlin會根據默認值來確定變量類型。

在定義類屬性時，定義的變量必須有默認值，而在定義函數中的局部變量時，可以不指定默認值，但是必須指定變量類型。

Kotlin使用var來定義變量，使用val來定義不可變值，而使用const來定義常量

變量定義

• 有默認值的變量定義方式： 在類屬性以及函數中都可以使用var來定義變量，如果沒有指定類型的話，Kotlin會根據默認值推導變量類型

class TestKotlin {
    var stringVar = "test"  // 定義字符串
    var intVar = 10 // 定義int類型的值
    var booleanVar = false // 定義boolean
    var floatVar = 1.0f // 定義float
    var longVar = 10L // 定義long
    var doubleVar = 10.0 // 定義dobule
    // 指定變量類型
    var stringTypeVar : String = "test" // 明確指定變量爲string類型
    var intTypeVar : Int = 10 // 明確指定變量爲int類型的值
}

• 無默認值的變量定義方式 這種方式只能在函數中定義，如果在類屬性中定義的話會報錯：Property must be initialize or be abstract

class TestKotlin {
    var intVar:Int =10
    var intTypeVar:Int  // Error：Property must be initialize or be abstract

    fun print(){
        var intVar:Int
    }
}

• 靜態變量的定義方式 可以在類的Top-Level定義變量，而在這個Level所聲明的變量就可以相當於Java中的Static靜態變量。在使用時，根據import的包名+類名來確定靜態變量。Kotlin中沒有static關鍵字。

// TestKotlin.kt
var staticInt:Int =10
class TestKotlin {

}
// 不同包下使用靜態變量
import com.example.myapplication.staticInt

class ApplicationKotlin {

    fun print(){
        staticInt
    }
}

不可變值的定義

不可變值的作用類似於Java中的final。但是與final有所不同，這部分後續再分析。官方文檔中說：對於類的屬性而言，var代表可變(Mutable)，而val代表不可變(Read-Only)

我們可以在類成員定義時，爲val定義的常量賦予初始值，如果不賦值的話，就會報錯。 而在函數的局部變量中定義val常量時候，可以後面再賦值，但是不可多次賦值，否則會報錯

class TestKotlin {
    val intVal : Int = 10

    fun print(){
        val intInsideVal:Int
        intInsideVal= 10
        val intInsideValInit=10
    }
}

類成員屬性中，使用val定義的值可以在構造函數內初始化，不過還是建議在定義時進行初始化

class TestKotlin {
    val intVal : Int
    
    constructor(){
        intVal=10
    }
    fun print(){
        val intInsideVal:Int
        intInsideVal= 10
        val intInsideValInit=10
    }
}

常量

Kotlin可以在類的Top-Level定義常量以及變量。而const則只能用於類Top-Level的常量聲明中。通過const val的聲明一個常量，const只能與val配對，不能使用var來配對

const val constString = "This is final String"

class TestKotlin {
       
}

基礎數據類型的轉換

在項目中通常會遇到基礎數據類型的轉換，如int類型的值+float類型的值。在Java中可以強轉，或者隱式轉換，如int+float=>int，而Kotlin中則不能直接強轉。

int值與long值是可以直接相加返回long值

class TestKotlin {

    fun test():Long{
        val intV:Int =10
        val longV :Long =10L
        val sumV=intV+longV
        return sumV
    }
}

int值與float值也可以直接相加返回float值

class TestKotlin {

    fun test():Float{
        val intV:Int =10
        val longV :Float =10.0F
        val sumV=intV+longV
        return sumV
    }
}

但如果我們希望int+float=>int的話，需要這麼做，使用toInt函數來返回int類型的值：

class TestKotlin {

    fun test():Int{
        val intV:Int =10
        val longV :Float =10.0F
        val sumV=intV+longV.toInt()
        return sumV
    }
}

同樣，還有toLong,toDouble等等用於數值轉換

函數

一個簡單函數會通過fun關鍵字來定義函數。

• 定義無返回值的函數

class TestKotlin {

    fun test(){
        println("this is a function")
    }
}

• 定義int返回值的函數

class TestKotlin {

    fun test():Int{
        println("this is a function and return int")
        return 0
    }
}

• 定義帶參數返回的函數

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

    fun add(x: Int, y: Int): Int {
        return x + y
    }
}

• 使用表達式作爲函數體，而返回值Kotlin會自動推斷

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

    fun add(x: Int, y: Int) = x + y
    fun add2(x: Int, y: Int):Int = x + y
}

• 定義類方法

import com.example.myapplication.add

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

}
// com.example.application下的類
fun add(x: Int, y: Int): Int = x + y
class ApplicationKotlin {


}

• 通過Lambda定義函數 如果需要返回值，則定義具體的返回值

class TestKotlin {

    fun test() {
        val add: (Int, Int) -> Int = { x, y -> x + y }
        add(10, 20)
    }
}

如果不需要返回值，則將返回值定義Unit即可

class TestKotlin {

    fun test() {
        val add: (Int, Int) -> Unit = { x, y -> print("") }
        add(10, 20)
    }

}

The type with only one value: the Unit object. This type corresponds to the `void` type in Java. Kotlin的文檔中也說明了，Unit是一個對象，而它也對應着Java中的void類型