Android：Kotlin詳細入門學習指南-基礎語法(一)

本人也是在初學Kotlin，如有錯誤，請幫忙指出，持續更新

Kotlin被Google官方認爲是Android開發的一級編程語言
自 2019 年 Google I/O 以來，Kotlin 就成爲了 Android 移動開發的首選。
首先來看看Kotlin的基礎語法

Kotlin是什麼

Kotlin是Android開發的一級編程語言（Google官方認證）
由JetBrains公司在2010年推出 & 開源，與Java語言互通 & 具備多種Java尚不支持的新特性
Android Studio3.0後的版本支持Kotlin

優點

碼更少、可讀性更強 - 花更少的時間來編寫代碼與理解他人的代碼
成熟的語言與環境 - 自 2011 年創建以來，Kotlin 不僅通過語言而且通過強大的工具在整個生態系統中不斷髮展。現在，它已無縫集成到 Android Studio 中，並被許多公司積極用於開發 Android 應用程序。
Android Jetpack 與其他庫中的 Kotlin 支持 - KTX 擴展爲現有的 Android 庫添加了 Kotlin 語言特性，如協程、擴展函數、lambdas 與命名參數。
與 Java 的互操作性 - 可以在應用程序中將 Kotlin 與 Java 編程語言一起使用，而無需將所有代碼遷移到 Kotlin。
支持多平臺開發 - 不僅可以使用 Kotlin 開發 Android，還可以開發 iOS、後端與 Web 應用程序。享受在平臺之間共享公共代碼的好處。
代碼安全 - 更少的代碼與更好的可讀性導致更少的錯誤。Kotlin 編譯器檢測這些剩餘的錯誤，從而使代碼安全。
易學易用 - Kotlin 非常易於學習，尤其是對於 Java 開發人員而言。
大社區 - Kotlin 得到了社區的大力支持與許多貢獻，該社區在全世界範圍內都在增長。根據 Google 的說法，Play 商店前 1000 個應用中有 60％以上使用 Kotlin。

使用

1、點擊Android Studio settings -> Plugins -> 搜索Kotlin Languages插件
2、在根目錄的build.gradle中加入

buildscript {
    ext.kotlin_version = '1.3.61'
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

3、在app/build.gradle中引入

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'

buildscript {
    ext.kotlin_version = '1.3.61'
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

基本語法

定義包名 - 在源文件的開頭定義包名：包名不必和文件夾路徑一致：源文件可以放在任意位置。

package my.demo 
import java.util.
* //...

定義函數：定義一個函數接受兩個 int 型參數，返回值爲 int

fun sum(a: Int , b: Int) : Int{ 
    return a + b 
}

fun main(args: Array<String>) {
    print("sum of 3 and 5 is ")
    println(sum(3, 5)) 
  }

該函數只有一個表達式函數體以及一個自推導型的返回值：

fun sum(a: Int, b: Int) = a + b 
fun main(args: Array<String>) {
    println("sum of 19 and 23 is ${sum(19, 23)}") 
 }

返回一個沒有意義的值：
Unit 的返回類型可以省略

fun printSum(a: Int, b: Int): Unit { 
    println("sum of $a and $b is ${a + b}")
     }
fun main(args: Array<String>) { 
printSum(-1, 8)
     }

定義局部變量
聲明常量：

fun main(args: Array<String>) {
     val a: Int = 1 // 立即初始化 
     val b = 2 // 推導出Int型 
     val c: Int // 當沒有初始化值時必須聲明類型 
     c = 3 // 賦值 
     println("a = $a, b = $b, c = $c")
  }

變量：

fun main(args: Array<String>) {
     var x = 5 // 推導出Int類型 
     x += 1 println("x = $x")
 }

註釋：
與 java 和 javaScript 一樣，Kotlin 支持單行註釋和塊註釋。

// 單行註釋
/* 哈哈哈哈 這是塊註釋 */

與 java 不同的是 Kotlin 的塊註釋可以級聯。
使用字符串模板

fun main(args: Array<String>) {
     var a = 1 // 使用變量名作爲模板: 
     val s1 = "a is $a" a = 2 // 使用表達式作爲模板:
     val s2 = "${s1.replace("is", "was")}, but now is $a" println(s2)
 }

使用條件表達式

fun maxOf(a: Int, b: Int): Int { 
    if (a > b) {
     return a 
     } else { 
     return b
      } 
 }
 fun main(args: Array<String>) { 
    println("max of 0 and 42 is ${maxOf(0, 42)}") 
 }

把if當表達式：

fun maxOf(a: Int, b: Int) = if (a > b) a else b
fun main(args: Array<String>) {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

使用可空變量以及空值檢查
當空值可能出現時應該明確指出該引用可空。
下面的函數是當 str 中不包含整數時返回空:

fun parseInt(str : String): Int?{ //... }

使用值檢查並自動轉換
使用 is 操作符檢查一個表達式是否是某個類型的實例。如果對不可變的局部變量或屬性進行過了類型檢查，就沒有必要明確轉換：

fun getStringLength(obj: Any): Int? {
 if (obj is String) { 
 // obj 將會在這個分支中自動轉換爲 String 類型 return obj.length }
 // obj 在種類檢查外仍然是 Any 類型 return null
 }

使用循環

fun main(args: Array<String>) {
     val items = listOf("apple", "banana", "kiwi") 
     for (item in items) {
      println(item) 
      }
}

或者這樣：

fun main(args: Array<String>) { 
    val items = listOf("apple", "banana", "kiwi") 
    for (index in items.indices) {
     println("item at $index is ${items[index]}") 
     } 
 }

使用 while 循環

fun main(args: Array<String>) { 
     val items = listOf("apple", "banana", "kiwi")
     var index = 0 while (index < items.size) { 
     println("item at $index is ${items[index]}")
      index++
      }
}

使用 when 表達式

fun describe(obj: Any): String = 
    when (obj) {
     1 -> "One" 
     "Hello" ->"Greeting" 
      is Long -> "Long" 
      !is String -> "Not a string" 
      else -> "Unknown" 
  }
  fun main(args: Array<String>) {
         println(describe(1)) println(describe("Hello"))
         println(describe(1000L))
         println(describe(2)) 
         println(describe("other"))
 }

使用ranges
使用 in 操作符檢查數值是否在某個範圍內：

fun main(args: Array<String>) { 
    val x = 10 
    val y = 9
     if (x in 1..y+1) {
      println("fits in range") 
      } 
 }

檢查數值是否在範圍外：

if (-1 !in 0..list.lastIndex) { 
    println("-1 is out of range") 
}

使用步進

for (x in 1..10 step 2)
for (x in 9 downTo 0 step 3)

使用集合

對一個集合進行迭代

fun main(args: Array<String>) { 
    val items = listOf("apple", "banana", "kiwi") 
    for (item in items) {
     println(item) 
     } 
 }

使用 in 操作符檢查集合中是否包含某個對象

fun main(args: Array<String>) { 
    val items = setOf("apple", "banana", "kiwi") 
    when { 
    "orange" in items -> println("juicy") 
    "apple" in items -> println("apple is fine too") 
    } 
}

使用lambda表達式過濾和映射集合

fun main(args: Array<String>) { 
    val fruits = listOf("banana", "avocado", "apple", "kiwi") 
    fruits 
    .filter { it.startsWith("a") } 
    .sortedBy { it } 
    .map { it.toUpperCase() } 
    .forEach { println(it) 
}

習慣用語

創建DTOs(POJOs/POCOs) 數據類
相當於java的Bean，

data class Customer(val name: String, val email: String)

給 Customer 類提供如下方法
-爲所有屬性添加 getters ，如果爲 var 類型同時添加 setters -- equals() - - haseCode() -- toString() -- copy()

函數默認值

fun foo(a: Int = 0, b: String = "") {...}

過濾 list

val positives = list.filter { x -> x >0 }

或者更短：

val positives = list.filter { it > 0 }

字符串插值

println("Name $name")

實例檢查

when (x) { 
    is Foo -> ... 
    is Bar -> ... 
    else -> ... 
}

遍歷 map/list

for ((k, v) in map) {
     print("$k -> $v") 
}

k,v 可以隨便命名
使用 ranges

for (i in 1..100) { ... } // 閉區間: 包括100 
for (i in 1 until 100) { ... } // 半開區間: 不包括100 
for (x in 2..10 step 2) { ... } 
for (x in 10 downTo 1) { ... } 
if (x in 1..10) { ... } 
for (i in 1..100) { ... } 
for (i in 2..10) { ... }

只讀 list

val list = listOf("a", "b", "c")

只讀map

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

訪問 map

println(map["key"]) 
map["key"] = value

懶屬性(延遲加載)

val p: String by lazy { // 生成string的值 }

擴展函數

fun String.spcaceToCamelCase() { ... } 
"Convert this to camelcase".spcaceToCamelCase()

創建單例模式

object Resource {
    val name = "Name"
}

如果不爲空則... 的簡寫

val files = File("Test").listFiles() 
println(files?.size)

如果不爲空...否則... 的簡寫

val files = File("test").listFiles() 
println(files?.size ?: "empty")

如果聲明爲空執行某操作

val data = ... 
val email = data["email"] ?: throw IllegalStateException("Email is missing!")

如果不爲空執行某操作

val date = ... 
data?.let{ ...//如果不爲空執行該語句塊 }

返回 when 判斷

fun transform(color: String): Int {
     return when(color) { 
     "Red" -> 0 "Green" -> 1 
     "Blue" -> 2 
     else -> throw IllegalArgumentException("Invalid color pa ram value")
      } 
}

try-catch 表達式

fun test() {
     val result = try {
      count() 
      }catch (e: ArithmeticException) {
       throw IllegaStateException(e)
      }//處理 result
}

if 表達式

fun foo(param: Int){ 
    val result = if (param == 1) { 
    "one"
     } else if (param == 2) { 
     "two" 
     } else {
      "three"
       }
}

需要泛型信息的泛型函數的方便形式

// public final class Gson { 
// ... 
// public <T> T fromJson(JsonElement json, Class<T> classOfT ) throws JsonSyntaxException { 
// ... inline 
fun <reified T: Any> Gson.fromJson(json): T = this.fromJs on(json, T::class.java)

命名風格

如有疑惑，默認爲Java編碼約定，比如：
使用駱

駝命名法(在命名中避免下劃線)
類型名稱首字母大寫
方法和屬性首字母小寫
縮進用四個空格
public 方法要寫說明文檔，這樣它就可以出現在 Kotllin Doc 中

冒號

在冒號區分類型和父類型中要有空格，在實例和類型之間是沒有空格的：

interface Foo<out T : Any> : Bar {
    fun foo(a: Int): T
}

Lambdas

在 Lambdas 表達式中，大括號與表達式間要有空格，箭頭與參數和函數體間要有空格。儘可能的把 lambda 放在括號外面傳入

list.filter { it > 10 }.map { element -> element * 2 }

在使用簡短而非嵌套的lambda中，建議使用 it 而不是顯式地聲明參數。在使用參數的嵌套lambda中，參數應該總是顯式聲明

類聲明格式

參數比較少的類可以用一行表示：

class Person(id: Int, name: String)

具有較多的參數的類應該格式化成每個構造函數的參數都位於與縮進的單獨行中。此外，結束括號應該在新行上。如果我們使用繼承，那麼超類構造函數調用或實現的接口列表應該位於與括號相同的行中

class Person( 
    id: Int, 
    name: String, 
    surname: String 
    ) : Human(id, name) {
     // ... 
}

對於多個接口，應該首先定位超類構造函數調用，然後每個接口應該位於不同的行中

class Person( 
    id: Int, 
    name: String, 
    surname: String 
    ) : Human(id, name), 
    KotlinMaker { // ... 
}

構造函數參數可以使用常規縮進或連續縮進(雙倍正常縮進)。

Unit

如果函數返回 Unit ，返回類型應該省略：

fun foo() { // ": Unit"被省略了 }

函數 vs 屬性

在某些情況下，沒有參數的函數可以與只讀屬性互換。儘管語義是相似的，但是有一些風格上的約定在什麼時候更偏向於另一個。
在下面的情況下，更偏向於屬性而不是一個函數:

不需要拋出異常 -- 擁有O(1)複雜度 -- 低消耗的計算(或首次運行結果會被緩存) -- 返回與調用相同的結果

Android：Kotlin詳細入門學習指南-基礎語法(一)