Kotlin的文法學習之旅

目錄

1.1 變量

1.2 if條件語句 、switch 條件語句

1.3 循環語句

1.4 類與對象和接口

1.5 單例模式

1.6 集合

1.7 線程

1.8 空指針檢查

1.1變量

```
val a = 10 
var a = 10

fun main() {
    val a: Int = 10;
    a = a * 10
    println(a)
}
```
           

 val不可變變量， var可變變量。 main聲明val報錯，可變的值需要var，并且Kotlin必須從一開始就确定類型是否可變。基本資料類型跟Java一樣，但不需要像Java書寫變量類型。直接指派自動識别、也可以通過  （：資料類型）來表示類型。

1.2 if條件語句、switch 條件語句

------if 

```
fun larginValue(pa1: Int, pa2: Int): Int {
    var value = if (pa1 > pa2) {
        pa1
    } else {
        pa2
    }
    return value
}

fun checkVale(par: Int, par2: Int) = if (par > par2) {
    par
}else {
    par2
}
```
           

-----switch

比對值 -> {執行邏輯}

```
fun caseName(name: String) {
    val sadas = when (name) {
        "tome" -> "12123"
        "tome2" -> "122"
        "tome3" -> "1231"
        else -> "1212"
    }
    println(sadas)
}

fun caseName(name: String) = when (name) {
    "tome" -> 1
    "asdsad" -> 2
    else -> null
}

fun checkVarType(num: Number) = when (num) {
    is Int -> println("is int")
    is Double -> println("is double")
    else -> ""
}

fun caseName2(name: String) = when {
    name.startsWith("tome") -> 86
    name == "123123" -> 88
    name == "123" -> 89
    else -> 1
}
```
           

1.3 循環語句

```
val range = 0..10
    for (i in range) {
        println(i)
    }

val range = 0 until 10
    for (i in range) {
        println(i)
    }

val range = 0..10
    for (i in range step 2) {
        println(i)
    }

val range = 0..10
    for (i in range) {
        println(i)
    }

val range = 0..10
    for (i in 10 downTo 0) {
        println(i)
    }
```
           

Kotlin循環有區間的概念，range是[]，除此直接in之外，還附帶了些别的函數

until  = [0,10)

step跳過，相當于i = i+2

downTo倒序

1.4 類與對象和接口

```
interface Study {
    fun readBook()
    fun doHome(){
        println("this is a test interface")
    }
}
```
```
class Student(val name: String, val age: String, hobby: String, like: String) :
    Persion(hobby, like), Study {

    constructor(name: String, age: String) : this(name, age, "", "")

    override fun toString(): String {
        return super.toString()
    }

    override fun readBook() {
        println("Student(name='$name', age='$age', hobby='$hobby', like='$like')")
    }

    override fun doHome() {
        super.doHome()
        println("Student(name='$name', age='$age', hobby='$hobby', like='$like')")
    }
}
```
```
open class Persion(val hobby: String, val like: String) {
}
```
           

open表示開放，可繼承。:  來繼承或者實作。 

接口方法 加花括号表示預設實作

Student(表示的預設值，和傳輸給你Persion的值)

constructor就是構造方法

1.5 單例模式

```
object Singleton {
    fun singleTest() {
        println("this is a single")
    }
}
```
           

這就表示是單例了

1.6 集合

```
fun main() {

    val arrayList = ArrayList<String>()
    arrayList.add("organg")
    arrayList.add("bear")
    arrayList.add("perar")
    arrayList.add("apple")

    //生成一個新的 list
    val listOf = listOf<String>("organg", "bear", "perar", "apple")
    val newList = listOf.filter { it.length > 5 }.map { it.toUpperCase() }
    for (fruit in newList) {
        println(fruit)
    }

    //mutable-x表示可更改的資料集. 用listOf生成的List無add
    val mutableListOf = mutableListOf("or", "1212")
    mutableListOf.add("!23123");


    val set = setOf("organg", "bear", "perar", "apple")
    for (se in set) {
        println(se)
    }

    //map建立于周遊
    val mapOf = mapOf("12" to 1, "22" to 2)
    for ((a, b) in mapOf) {
        println(a + b)
    }

    //map另外一種建立于替換
    val hashMap = HashMap<String, String>()
    hashMap["orange2"] = "2"
    hashMap["orange3"] = "3"
    hashMap["orange4"] = "1"
    hashMap.put("1", "or")
    for ((a, b) in hashMap) {
        println(a + "===" + b)
    }

    //map另外一種建立于替換
    val hashMap2 = HashMap<String, String>()
    hashMap2.put("1", "orange1")
    hashMap2.put("2", "orange2")
    hashMap2.put("3", "orange3")
    for ((a, b) in hashMap2) {
        println(a + "===" + b)
    }
}
```
           

1.7 線程

```
fun main() {
    //線程簡化
    //1-
    Thread(object : Runnable {
        override fun run() {
            println("this is a thread - 1")
        }
    }).start()

    //2-
    // 根據kotlin文法，可以對其簡化
    Thread({
        println("this is a thread - 2")
    }).start()

    //3-
    Thread {
        println("this is a thread - 3")
    }.start()
}
```
           

1.8 空指針檢查

```
var content: String? = "adasdasd"

fun main() {
    printUpss()
}

fun printUpss() {
    // ?： 左側是不為空 右側為 為空的處理
    // ?. 表示判空處理 - 傳回 null
    // val toUpperCase = content?.toUpperCase() ?: "123123"

    // !!. 表示強制執行，不管驗證
    val toUpperCase = content!!.toUpperCase()
    println(toUpperCase)
}

fun doStudy2(study: Student?) {
    // kotlin預設所有變量對象都不可為null
    // 打 ？ 表示可為空
    study?.doHome()
    study?.readBook()

    // ?： 左側是不為空 右側為 為空的處理
    // ?. 表示判空處理 - 傳回 null
    study?.doHome() ?: "1"
}
```