Kotlin 的基礎(chǔ)語(yǔ)法

從這一篇文章開(kāi)始正式進(jìn)入 Kotlin 的語(yǔ)法介紹，旨在從整體上體會(huì)一下 Kotlin 的代碼風(fēng)格和基本的編程規(guī)范，其中會(huì)將 Kotlin 語(yǔ)法與 Java 語(yǔ)法做一個(gè)簡(jiǎn)單的對(duì)比，從而更快更好地了解 Kotlin。

1. 包的聲明和導(dǎo)入

在 Kotlin 中定義包與 Java 有點(diǎn)不同，在 Kotlin 中目錄與包結(jié)構(gòu)無(wú)需匹配，Kotlin 的源碼可以在磁盤(pán)上的任意位置。與 Java 不一樣的是 Kotlin 的文件是以 .kt 為后綴，而 Java 的文件是以 .java 為后綴。

1.1 包的聲明

源文件的通常是以包的聲明的開(kāi)頭和 Java 一樣，都是使用 package 關(guān)鍵字。

package com.imooc.hello.kotlin //package 關(guān)鍵字聲明包

fun main(args: Array<String>) {
    println("Hello Kotlin")
}

1.2 包的導(dǎo)入

包的默認(rèn)導(dǎo)入

在 Kotlin 中一些內(nèi)置庫(kù)的包是默認(rèn)導(dǎo)入（或稱(chēng)隱式導(dǎo)入）的，比如以下這些庫(kù)的包都是 Kotlin 默認(rèn)導(dǎo)入:

kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*

舉個(gè)例子說(shuō)明下，比如在 Kotlin 中使用集合List或者MutableList時(shí)，并不需要顯式的import kotlin.collections.* 聲明，就能使用相關(guān)集合的 API。

package com.imooc.hello.kotlin 

fun main(args: Array<String>) {
    val languages: List<String> = listOf("Kotlin"， "Java"， "Dart")//聲明了List，但是不需要顯示導(dǎo)入kotlin.collections.*
    languages.forEach { language ->
       println(language)       
    }
}

包的顯示導(dǎo)入

在 Kotlin 中的包顯示導(dǎo)入是使用 import 關(guān)鍵字，這一點(diǎn)和 Java 是一樣的。以 Android 中的MainActivity舉例

  package com.imooc.hello.kotlin

  import android.os.Bundle // import關(guān)鍵字顯示導(dǎo)入包和java是一樣的
  import androidx.appcompat.app.AppCompatActivity
  import kotlinx.android.synthetic.main.activity_main.*

  class MainActivity : AppCompatActivity() {

      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_main)
          tv_hello.text = "Hello Kotlin!"
      }
  }

2. 函數(shù)

2.1 函數(shù)的定義

函數(shù)的定義使用關(guān)鍵字fun，函數(shù)參數(shù)格式為: “參數(shù):類(lèi)型”，函數(shù)返回值類(lèi)型 fun(...): Int。這種聲明函數(shù)參數(shù)、函數(shù)返回值類(lèi)型方式正好與 Java 是相反的。

//Kotlin定義
fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

//Java定義
public int sum(int a, int b, int c) {
    return a + b + c;
}

2.2 函數(shù)類(lèi)型推導(dǎo)

表達(dá)式作為函數(shù)體，返回值的類(lèi)型可以省略，可以利用 Kotlin 的類(lèi)型推導(dǎo)功能，推測(cè)出函數(shù)返回值的類(lèi)型。

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

//可簡(jiǎn)寫(xiě)成以下形式
fun sum(a: Int, b: Int, c: Int) = a + b + c

2.3 無(wú)返回值的函數(shù)

在 Java 中定義無(wú)返回值類(lèi)型的函數(shù)一般是使用void， 在 Kotlin 中則使用Unit， 或者省略Unit類(lèi)型。

//Kotlin定義
fun output(userName: String): Unit {
    println("current user name is $userName")
}
//可簡(jiǎn)寫(xiě)成以下形式
fun output(userName: String) {
    println("current user name is $userName")
}

//Java定義
public void output(String userName) {//注意在Java中 void不能省略
    System.out.println("current user name is " + userName);
}

2.4 可變長(zhǎng)參數(shù)函數(shù)

在 Kotlin 中可變長(zhǎng)參數(shù)函數(shù)可以使用vararg關(guān)鍵字標(biāo)識(shí)，這一點(diǎn)和Java中的可變長(zhǎng)參數(shù)聲明不一樣。

//Kotlin定義
fun setDatas(vararg datas: Any) {
    for (dataItem in datas) {
        print(dataItem)
    }
}

//Java定義
public void setDatas(Object... datas) {
    for (dataItem in datas) {
        System.out.println(dataItem.toString());
    }
}

2.5 lambda(匿名函數(shù))

val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }

//調(diào)用
println("sum = ${sumLambda(1, 6, 7)}")

3. 常量和變量

常量與變量都可以沒(méi)有初始化值，但是在引用前必須初始化編譯器支持自動(dòng)類(lèi)型判斷，即聲明時(shí)可以不指定類(lèi)型，由編譯器判斷。如果不在聲明的時(shí)候初始化則必須提供變量的類(lèi)型

3.1 可變變量的定義

可變變量的定義：var 關(guān)鍵字：

var <變量名>:<變量類(lèi)型> = <初始值>

var sum: Int = 3
sum = 8

//由于編譯支持類(lèi)型推導(dǎo)可以省略Int類(lèi)型
var sum = 3
sum = 8

3.2 只讀變量的定義

只讀變量的定義: val 關(guān)鍵字， 不能進(jìn)行二次賦值，類(lèi)似 Java 中的 final 類(lèi)型

val <常量名>:<常量類(lèi)型> = <初始值>

val sum: Int //沒(méi)有賦值初始化之前必須指定類(lèi)型
sum = 5

4. 字符串模板

模板中的簡(jiǎn)單的單值：

fun main(args: Array<String>) {
    var a = 1
    var s1 = "a is $a"
}

模板中的任意表達(dá)式的值：

fun main(args: Array<String>) {
    var a = 1
    a = 2
    val s2 = "${s1.replace("is"， "was")}， but now is $a"
}

5. 注釋

Kotlin 支持單行和多行注釋?zhuān)蚸ava中類(lèi)似。

fun main(args: Array<String>) {
//    println("Hello Kotlin!") 單行注釋
}

fun main(args: Array<String>) {
//多行注釋 /* ... */
    /*println("Hello Kotlin!")
    println("Hello Kotlin!")
    println("Hello Kotlin!")*/
    println("Hello Kotlin!")
}

6. 條件表達(dá)式

Kotlin 使用 if-else 表達(dá)式替代了 Java 中的三目運(yùn)算符， 因?yàn)樵?Kotlin 中 if-else 表達(dá)式是帶有返回值的。

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

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

在 Kotlin 中 if 表達(dá)式是帶有返回值的，所以可以簡(jiǎn)化成下面的形式：

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

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

7. 空安全

Kotlin 的空安全設(shè)計(jì)對(duì)于聲明可為空的參數(shù)，在使用時(shí)要進(jìn)行空判斷處理，有兩種處理方式，字段后加!!像 Java 一樣拋出空異常，另一種字段后加?可不做處理返回值為 null 或配合 ?: 做空判斷處理

//類(lèi)型后面加?表示可為空
var age: String? = "23"
//字段后面加"!!"拋出空指針異常
val ages = age!!.toInt()
//字段后面加”？“不做處理返回 null
val ages1 = age?.toInt()
//使用”?:“ 表示age為空返回-1
val ages2 = age?.toInt() ?: -1

當(dāng)一個(gè)引用可能為 null 值時(shí)， 對(duì)應(yīng)的類(lèi)型聲明必須明確地在類(lèi)型后面標(biāo)記為”？“表示可為 null。 當(dāng) str 中的字符串內(nèi)容不是一個(gè)整數(shù)時(shí)， 返回 null：

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("Two Integers Expected")
        return
    }
    val x = parseInt(args[0])
    val y = parseInt(args[1])

    //println(x + y) 由于標(biāo)識(shí)了可能為null,直接使用x + y在編譯器看來(lái)是非法，需要去做非空判斷
    if (x != null && y != null) {
        println(x + y)
    }
}

fun parseInt(s: String): Int? {//表示當(dāng)前函數(shù)返回值可能為null,就必須在類(lèi)型后面標(biāo)識(shí)"?"
    return s.toInt()
}

8. 類(lèi)型智能推導(dǎo)和自動(dòng)類(lèi)型轉(zhuǎn)換

在 Kotlin 中可以使用 is 運(yùn)算符檢測(cè)一個(gè)表達(dá)式是否某類(lèi)型的一個(gè)實(shí)例(類(lèi)似于Java 中的instanceof關(guān)鍵字)。

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // 做過(guò)類(lèi)型判斷以后，obj會(huì)被系統(tǒng)自動(dòng)轉(zhuǎn)換為String類(lèi)型
        return obj.length
    }

    //在這里還有一種方法，與Java中instanceof不同，使用!is
    // if (obj !is String){
    //   // XXX
    // }

    // 這里的obj仍然是Any類(lèi)型的引用
    return null
}

或者是這樣的：

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null
  // 在這個(gè)分支中， `obj` 的類(lèi)型會(huì)被自動(dòng)轉(zhuǎn)換為 `String`
  return obj.length
}

甚至還可以是這樣的：

fun getStringLength(obj: Any): Int? {
  // 在 `&&` 運(yùn)算符的右側(cè)， `obj` 的類(lèi)型會(huì)被自動(dòng)轉(zhuǎn)換為 `String`
  if (obj is String && obj.length > 0)
    return obj.length
  return null
}

9. 區(qū)間 Range

在 Kotlin 中使用in運(yùn)算符來(lái)檢測(cè)某個(gè)數(shù)字是否在指定的區(qū)間內(nèi)，區(qū)間表達(dá)式具有操作符形式"…"的rangeTo函數(shù)輔助in和!in組合而成。區(qū)間可以支持任何可以比較的類(lèi)型，對(duì)于原生的整型，內(nèi)部有一個(gè)優(yōu)化的實(shí)現(xiàn)。

比如以下幾種使用場(chǎng)景:

1. 檢測(cè)某個(gè)數(shù)字是否在指定區(qū)間內(nèi)：

val x = 10
val y = 9
if (x in 1..y + 1) {//表示x是否在1~y+1范圍內(nèi)。
    println("fits in range")
}

2. 檢測(cè)某個(gè)數(shù)字是否在指定區(qū)間外：

val list = listOf("a"， "b"， "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}

if (list.size !in list.indices) {
    println("list size is out of valid list indices range too")
}

3. 區(qū)間迭代：

for(x in 1..10){//相當(dāng)于 x >= 1 && x <= 10
    println(x)
}

//或者
fun printList(num: Int) {
    for (i in 1..num) {//相當(dāng)于 i >= 1 && i <= num
        print(i)
    }
}

//或者使用until 函數(shù)排除結(jié)束元素
for (i in 1 until 10) {// i in [1, 10) 排除了 10,相當(dāng)于 i >= 1 && i < 10
    println(i)
} 

4. 數(shù)列迭代 ：

for(x in 1..100 step 2){//遞增數(shù)列迭代，每次間隔步長(zhǎng)是2；1，3，5，7...
    println(x)
}

for(x in 9 downTo 0 step 3){//遞減數(shù)列迭代，每次間隔步長(zhǎng)是3；9，6，3，0
    println(x)
}  

10. 集合的使用

1. 對(duì)集合進(jìn)行迭代：

fun main(args: Array<String>) {
    val items = list.of("java"， "kotlin"， "python")
    for (item in items) {
        println(item)
    }
}

2. 使用 in 運(yùn)算符判斷集合內(nèi)是否包含某個(gè)實(shí)例：

when {
    "java" in items -> println("is good lang")
    "kotlin" in items -> println("is good good lang")
    else -> println("python is best lang")
}

3. 使用 lambda 表達(dá)式來(lái)過(guò)濾(filter)和映射(map)集合：

fun main(args: Array<String>) {
    val langs = listOf("C"， "C++"， "Java"， "Python"， "JavaScript")

    langs.filter { it.startsWith("C") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { println(it) }
}

11. 循環(huán)的使用

在 Kotlin 中的循環(huán)有兩種方式分別是for，while，在for循環(huán)中使用"in"來(lái)遍歷，并且有兩個(gè)遍歷方式。

1. for 循環(huán)：

val items = listOf("java"， "kotlin"， "android")
for (item in items) {//for遍歷集合
    println("lang $item")
}

for (index in items.indices) {//類(lèi)似于java中的數(shù)組的length-index的遍歷
    println("The $index index is ${items[index]}")
}

2. while 循環(huán)：

val items = listOf("java"， "kotlin"， "android")
var index = 0
while (index < items.size) {//while 循環(huán)的遍歷方式
    println("The $index lang is ${items[index++]}")
}

12. 條件if,when的使用

在 kotlin 中 if 的使用于 Java 相似但是在 kotin 中 if 是表達(dá)式有值的，而在 java 中是語(yǔ)句，可以使用kotlin 中的 if 表達(dá)式替代 Java 中的三目運(yùn)算符在 kotlin 中的。when 與 switch 功能類(lèi)似：

fun main(args: Array<String>) {
    println(descript("hello"))
}

fun descript(obj: Any): String = when (obj) {
    1 -> "one"
    "hello" -> "hello word"
    is Long -> "long type"
    !is String -> "is not String"
    else -> {
        "unknown type"
    }
}

13. 類(lèi)和對(duì)象

類(lèi)和對(duì)象的形式這里先簡(jiǎn)單了解，后續(xù)我們會(huì)有專(zhuān)門(mén)的章節(jié)進(jìn)行講解：

fun main(args: Array<String>) {
    val rectangle = Rectangle(100.0, 200.0)
    val triangle = Triangle(100.0, 100.0, 100.0)
    println("rectangle is ${rectangle.isSquare}， and perimeter is ${rectangle.perimeter}， and area is ${rectangle.calculateArea()}")
    println("triangle  perimeter is ${triangle.perimeter}， and area is ${triangle.calculateArea()}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperity {
    val isSquare: Boolean
}

class Rectangle(var height: Double, var length: Double)
    : Shape(listOf(height, length, height, length))， RectangleProperity {
    override fun calculateArea(): Double = height * length
    override val isSquare: Boolean get() = height == length
}

class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
    : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double = sideA * sideB * sideC
}

14. 小結(jié)

到這里有關(guān)初探 Kotlin 語(yǔ)法就結(jié)束，這一篇僅僅為了整體上去體驗(yàn)下 Kotlin 編程風(fēng)格和代碼規(guī)范，下面將會(huì)深入每個(gè)語(yǔ)法細(xì)節(jié)進(jìn)行深入展開(kāi)。