Android Kotlin-1 基本語法1

已經文章陸續轉至www.codeilin.com

下面內容有，最後更新於2020/12/06 16:19
1.var 可變變數
2.val 不可變更參數
3.Array 用法
4.ArrayList 用法
5.when 用法
6.fun 函式用法
7.if 表達式
8.for 表達式
9.擴充函數(自定義函式)
10.操作符重載
11.資料區間用法
12.map使用方法
13.內部靜態變數
14.靜態變數
15.當資料如果是?型態宣告
16.資料使用!!，強制將Int?轉Int
17.data class用法
18.強制轉型
19.run、with、apply、also用法

1. var 可變變數

   var data: Int = 0
   data = 1//可以中途變更參數
   //不初始化參數，必須要表明是什麼型態，如Int，這個用法通常是之後再初始化時，會用到
   lateinit var: Int
   

2. val 不可變更參數

   val data: String = “123”
   data = “123434”//錯誤不可這樣設定
   

3. Array 用法

    var array:Array<Char> = arrayOf('1','2','3','4','5')//建立
    //array.forEach遍歷所有array
    array.forEach { println("$it") }//此時打印出1 2 3 4 5
    array = array.plus('6')//新增
    array.forEach { println("$it") }//此時打印出1 2 3 4 5 6
    array.reverse()//資料翻轉
    array.forEach { println("$it") }//此時打印出6 5 4 3 2 1
    //遍歷的另一種方法，此方法可以知道index，也可以知道value
    for((index,value) in array.withIndex()) {
        println("$index -> $value")
    }
   

4. ArrayList 用法

    fun onArrayListChange() {
        //此處得ArrayList與Java的ArrayList是一致的
        //kotlin多了一個MutableList，用法與ArrayList幾乎相同
        //建立ArrayList
        //var arrayList: ArrayList<String> = arrayListOf()
        //建立MutableListOf
        var arrayList: MutableList<String> = arrayListOf()
        arrayList.add("123")//新增123
        arrayList.add("234")//新增234
        arrayList.add(0,"aaa")//在list index = 0 位置新增aaa
        println("AA -> $arrayList")//AA -> [aaa, 123, 234]
        arrayList.removeAt(0)//刪除位置index = 0的資料
        println("BB -> $arrayList")//BB -> [123, 234]
        arrayList.clear()
        println("CC -> $arrayList")//CC -> []
    }
   

5. when 用法

    //第一種
    val string = "123"
    when(string) {
        "123" -> {
   
        }
    }
    //第二種
    val string = "123"
    val string1 = "234"
    when {
        string == "123" && string1 == "234" -> {
   
        }
        else -> {
   
        }
    }
    //第三種
    val data: Int? = 100 
    when(data) {
        is Int -> {
   
        }
        in 0..100 -> {
   
        }
    }
   

6. fun 函式用法

    //第一種
    fun sum(a: Int, b: Int): Int {
        return a+b
    }
    println("${sum(1,2)}")//打印3
    //第二種
    fun sum(a: Int, b: Int) =  a + b
    println("${sum(1,2)}")//打印3
    //第三種
    fun sum(a: Int = 5, b: Int) =  a + b
    println("${sum(b=2)}")//打印7
    //第四種
    var sum = {arg1: Int,arg2: Int ->
        arg1 + arg2
    }
    println("${sum(100,10)}")//打印110
    //第五種(進階用法)
    fun calculationFun():() -> Unit {
        var data1 = 10
        var data2 = 20
        return {
            data1-=1
            data2+=2
            println("data1 = $data1, data2 = $data2")
        }
    }
    val calculationFun1 = calculationFun()
    calculationFun1() //打印data1 = 9, data2 = 22
    calculationFun1() //打印data1 = 8, data2 = 24
   

7. if 表達式

    //如果string == "123", result = 0
    //如果string == "234", result = 1
    //如果其他的話, result = 2
    val result = if(string == "123") {
        0
    } else if(string == "234") {
        1
    } else {
        2
    }
   

8. for 表達式

    val items = listOf("data1", "data2", "data3")
    //此方式，可以直接取到該index裡面的值
    for (item in items) {
        println("item = ${item}")
    }
    //此方法，可以直接取得當前index
    for (index in items.indices) {
        println("item = ${items[index]}")
    }
   

9. 擴充函數(自定義函式)

    class TestClass {
        private val addPrice = 100
        infix fun addPrice(value: Int): Int {
            return value+addPrice
        }
    }
   
    val testClass = TestClass()
    val result = testClass addPrice 1
    println("result = ${result}")//打印出101
   

10. 操作符重載
    這裡只舉例，因為數量很多，其他請各位舉一反三囉，參考此處

    class ReloadOperator(var arg1: Double,var arg2: Double) {
        operator fun plus(value: Double): ReloadOperator {
            return ReloadOperator(arg1+value, arg2+value)
        }
    
        operator fun invoke(): Double {
            return arg1+arg2
        }
    }
    val test = ReloadOperator(10.0,30.0)
    val data = test + 10.0 //會執行plus
    //data()會執行invoke()
    println("data = ${data.arg2} data2 = ${data()}")
    //data = 40.0 data2 = 60.0
    

11. 資料區間用法

    for(index in 0 until 5) {
        println("index = $index")
        //0 1 2 3 4
    }
    for(index in 0..5) {
        println("index = $index")
        //0 1 2 3 4 5
    }
    for(index in 10 downTo 0 step 3) {
        println("index = $index")
        //10 7 4 1
    }
    

12. map使用方法

    //可讀可寫 mutableMapOf
    //只可讀 mapOf
    //第一種：可讀可寫
    val map = mutableMapOf("a" to 20, "b" to "AAA", "c" to 10.0)
    map["a"] = 32
    println("map ${map["a"]}") //打印 map 32
    
    //第二種：可讀不可寫
    val map = mapOf("a" to 1, "b" to 2, "c" to 3)
    map["a"] = 32 //錯誤導致無法編譯
    println("map ${map["a"]}") //打印 map 1
    
    //遍歷map
    for((key, value) in map) {
        println("key = $key, value = $value")
    }
    

13. 內部靜態變數，使用lib的方法也如下

    class AAA {
        companion object {
            const val data1 = 1
            const val data2 = 2
            init {
                System.loadLibrary("native-lib")
            }
        }
    }
    class BBB {
        fun setData(data: Int) {
            AAA.data1 = 2
            if(AAA.data2 == 2) {
                println("data = ${AAA.data2}")
            }
        }
    }
    

14. 靜態變數

    object SDK {
        var init? = false
    }
    class main {
        fun initData(flag: Boolean?) {
            if SDK.init != null {
                SDK.init = true
            }    
        }
    }
    

15. 當資料如果是?型態宣告的話，如下

    fun isCount(data: Int?): Int {
        return data ?: 0
    }
    

    這段意思是返回值必為整數，如果是null的話自動改為0

16. 資料使用!!，強制將Int?轉Int，必不為null的話，注意使用!!是null會異常發生

    fun isCount(data: Int?): Int {
        if(data != null) {
            return data!!
        }
        return 0
    }
    

17. data class用法

    data class Book(var name: String, var price: Int) {
        fun plusPrice(value: Int) {
            //plus 是將price+value在返回值
            price = price.plus(value)
        }
        fun minusPrice(value: Int) {
            //minus 是將price-value在返回值
            price = price.minus(value)
        }
    }
    val book: Book? = Book("AABBCC", 59)
    println("price = ${book?.price}") //輸出59
    book?.plusPrice(10)
    println("price = ${book?.price}") //輸出69
    book?.minusPrice(20)
    println("price = ${book?.price}") //輸出49
    

18. 強制轉型

    fun main() {
        var data1: String = "1234"
        var data2: Int = 20
        onDataChange(data1)
        onDataChange(data2)
    }
    fun onDataChange(data: Any) {
        val data1: String? = data as? String
        val data2: Int? = data as? Int
        if(data1 != null) {
            //有資料
            println("{data1 ${data1}}")
        }
        if(data2 != null) {
           //有資料
           println("{data2 ${data2}}")
        }
    }
    

19. run、with、apply、also用法，套用17.的data class Book
    當run是null時，最後回傳是null
    因為run的內部不會有?
    

    //第一種
    book?.run {
        //run內部時，是this
        println("this $this ------------ name $name")
        true
    }.let {//run 和 with都是回傳最後一行
        //此時的it是true
        println("$it")
    }
    //第二種
    book = null     //run有檢查空的功能，所以這樣不會導致閃退
    book?.run {
        println("this $this ------------ name $name")
        true
    }.let {
        //此時的it是null
        println("$it")
    }
    

    當with是null時，最後回傳的依然是最後一行
    因為with的內部可以有?
    

    //第一種
    with(book as Book?) {
        println("this $this ------------ name this?.$name")
        true
    }.let {//run 和 with都是回傳最後一行
        //此時的it是true
        println("$it")
    }
    //第二種
    book = null     
    with(book as Book?) {
        println("this $this ------------ name this?.$name")
        true
    }.let {
        //此時的it是true
        println("$it")
    }
    

    apply

    ArrayList<String>().apply {
        add("1234")
        add("3456")
    }.let {
        //整理好的資料是it
        println("this $it size ${it.size}")//此時輸出size = 2
        sendArrayList(it)//將整理好的資料發送給其他地方用
    }
    

    also

    ArrayList<String>().also {
        //it是剛建立好的ArrayList
        it.add("1234")
        it.add("3456")
        println("this $it size ${it.size}")
        sendArrayList(it)//將整理好的資料發送給其他地方用
    }
    

目前就先寫到這啦，之後有想到還有什麼重要的，會在陸續更新