Kotlin學習筆記2——基本語法

前言

上一篇，我們學習了Kotlin中常用的基本數據類型，今天繼續來學習Kotlin中常用的基本語法。

包的定義與導入

包的聲明應處於源文件頂部：

package my.demo //包名定義
import kotlin.text.*  //導入包 
fun test() {} //函數定義，後面會講
class Runoob {} //類定義，後面會講

目錄與包的結構無需匹配：源代碼可以在文件系統的任意位置

程序入口點

Kotlin 應用程序的入口點是 main 函數。

fun main() {
    println("Hello world!")
}

變量定義

可變變量定義：var 關鍵字，不可變變量定義：val 關鍵字，只能賦值一次的變量(類似Java中final修飾的變量)，定義變量的模板爲：

val <標識符> : <類型> = <初始化值>

常量與變量定義時都可以沒有初始化值,但是在引用前必須初始化
編譯器支持自動類型判斷,即聲明時可以不指定類型,由編譯器判斷。

val a: Int = 1
val b = 1       // 系統自動推斷變量類型爲Int
val c: Int      // 如果不在聲明時初始化則必須提供變量類型
c = 1           // 明確賦值

var x = 5        // 系統自動推斷變量類型爲Int
x += 1           // 變量可修改

如果變量再定義時不初始化值，可以用lateinit關鍵字修飾，然後後面在賦值

lateinit var a: Int
...
fun initData(){
	a = 10
}

函數定義

定義函數用fun關鍵字，格式爲：fun 函數名(參數名：參數類型,參數名：參數類型,…)：返回類型（參數可以用多個）。
定義一個帶有兩個 Int 參數、返回 Int 的函數：

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

將表達式作爲函數體、返回值類型自動推斷的函數：

fun sum(a: Int, b: Int) = a + b

函數返回無意義的值，類似Java中的void：

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

Unit 返回類型可以省略：

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

可變長參數函數

函數的變長參數可以用 vararg 關鍵字進行標識：

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}
// 測試
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 輸出12345
}

lambda(匿名函數)

sumLambda匿名函數名，第一個括號中兩個Int類型爲參數類型，->後面是返回結果類型，=號後表達式是函數體，函數體中的x、y表示參數的實例，第二個->後面是具體的邏輯。

// 測試
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 輸出 3
}

註釋

與大多數現代語言一樣，Kotlin 支持單行（或行末）與多行（塊）註釋。

// 這是一個行註釋

/* 這是一個多行的
   塊註釋。 */

Kotlin 中的塊註釋可以嵌套。

/* 註釋從這裏開始
/* 包含嵌套的註釋 */     
並且在這裏結束。 */

字符串模板

這個在上篇文章Kotlin中常用的基本數據類型已經講過了，這裏再重新溫習下。
字符串字面值可以包含模板表達式 ，即一些小段代碼，會求值並把結果合併到字符串中。 模板表達式以美元符（$）開頭，由一個簡單的名字構成:

val i = 10
println("i = $i") // 輸出“i = 10”

或者用花括號括起來的任意表達式:

val s = "abc"
println("$s.length is ${s.length}") // 輸出“abc.length is 3”

原始字符串與轉義字符串內部都支持模板。 如果你需要在原始字符串中表示字面值 $ 字符（它不支持反斜槓轉義），你可以用下列語法：

val price = """
${'$'}9.99
"""

條件表達式

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

在 Kotlin 中，if 也可以用作表達式：

fun maxOf(a: Int, b: Int) = if (a > b) a else b

空值與 null 檢測

Kotlin的空安全設計對於聲明可爲空的參數，在使用時要進行空判斷處理，有兩種處理方式，字段後加!!像Java一樣拋出空異常，另一種字段後加?可不做處理返回值爲 null或配合?:做空判斷處理

//類型後面加?表示可爲空
var age: String? = "23" 
//age如果爲空，拋出空指針異常
val ages = age!!.toInt()
//age如果爲空，不做處理返回 null
val ages1 = age?.toInt()
//age如果爲空，配合?:使用返回-1
val ages2 = age?.toInt() ?: -1

當一個引用可能爲 null 值時, 對應的類型聲明必須明確地標記爲可爲 null。
以下實例演示如何使用一個返回值可爲 null 的函數:

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // 直接使用 `x * y` 會導致編譯錯誤，因爲它們可能爲 null
    if (x != null && y != null) {
        // 在空檢測後，x 與 y 會自動轉換爲非空值（non-nullable）
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' is not a number")
    }    
}

for 循環

val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
    println(item)
}
//或者
val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

有關for 循環更多詳細的用法，我們後面講循環的時候再說，這裏只展示基本用法。

when 表達式

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }

有關when 表達式更多詳細的用法，我們後面講when 表達式的時候再說，這裏只展示基本用法。

區間

區間表達式由具有操作符形式 … 的 rangeTo 函數輔以 in 和 !in 形成。

區間是爲任何可比較類型定義的，但對於整型原生類型，它有一個優化的實現。以下是使用區間的一些示例:

for (i in 1..4) print(i) // 輸出“1234”

for (i in 4..1) print(i) // 什麼都不輸出

if (i in 1..10) { // 等同於 1 <= i && i <= 10
    println(i)
}

// 使用 step 指定步長
for (i in 1..4 step 2) print(i) // 輸出“13”

for (i in 4 downTo 1 step 2) print(i) // 輸出“42”


// 使用 until 函數排除結束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

集合

• Kotlin集合類可以分爲：可變集合類（Mutable）和不可變集合類（Immutable）。
• 常用的集合類主要有三種：List（列表）、Set（集）和Map（映射）
• List容器中的元素以線性方式存儲，集合中可以存放重複對象。列表中的數據是有序排列
• Set集容器的元素無序、不重複。
• Map映射的持有的是 鍵值對 對象每一個對象都包含一堆 K-V對象。Map存儲的容器中每一個對象都有一個Key對象，Key決定對象在容器中的位置。關鍵字Key是唯一的。關鍵字本身並不能決定對象的存儲位置，它通過散列產生一個 散列碼 的整數值，這個散列碼對應值Value的存儲位置。
• 如果從數據結構本身來看List中的下標就是Key，只不過key是有序的Int類型，所以說List也可以成爲特殊的Map數據結構。而Set也是Key爲Int值，但是Value不能重複。

這裏以List爲例對集合進行迭代:

var items = listOf(1,2,3,4)
for (item in items) {
    println(item)
}

使用 in 運算符來判斷集合內是否包含某實例：

when {
    "orange" in items -> println("juicy")
    "apple" in items -> println("apple is fine too")
}

使用 lambda 表達式來過濾（filter）與映射（map）集合：

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
  .filter { it.startsWith("a") }
  .sortedBy { it }
  .map { it.toUpperCase() }
  .forEach { println(it) }

這裏先大概展示下集合的常用的使用方法，詳細用法後面講集合的時候再介紹。

創建基本類及其實例

相比java創建對象再也不用new了

val rectangle = Rectangle(5.0, 2.0)
val triangle = Triangle(3.0, 4.0, 5.0)

尾巴

今天的學習筆記就先到這裏了，下一篇我們將學習Kotlin中的條件控制。
老規矩，喜歡我的文章，歡迎素質三連：點贊，評論，關注，謝謝大家！