Kotlin 基礎語法

Kotlin 文件以 .kt 為後綴。

包聲明

代碼文件的開頭一般為包的聲明：

package com.runoob.mainimport java.util.*fun test() {}class Runoob {}

kotlin源文件不需要相匹配的目錄和包，源文件可以放在任何文件目錄。

以上例中 test() 的全名是 com.runoob.main.test、Runoob 的全名是 com.runoob.main.Runoob。

如果沒有指定包，默認為 default 包。

默認導入

有多個包會默認導入到每個 Kotlin 文件中：

• kotlin.*

• kotlin.annotation.*

• kotlin.collections.*

• kotlin.comparisons.*

• kotlin.io.*

• kotlin.ranges.*

• kotlin.sequences.*

• kotlin.text.*

函數定義

函數定義使用關鍵字 fun，參數格式為：參數 : 類型

fun sum(a: Int, b: Int): Int { // Int 參數，返回值 Int return a + b}

表達式作為函數體，返回類型自動推斷：

fun sum(a: Int, b: Int) = a + bpublic fun sum(a: Int, b: Int): Int = a + b // public 方法則必須明確寫出返回類型

無返回值的函數(類似Java中的void)：

fun printSum(a: Int, b: Int): Unit { print(a + b)}// 如果是返回 Unit類型，則可以省略(對於public方法也是這樣)：public fun printSum(a: Int, b: Int) { print(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(匿名函數)

lambda表達式使用實例：

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

定義常量與變數

可變變數定義：var 關鍵字

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

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

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

常量與變數都可以沒有初始化值,但是在引用前必須初始化

編譯器支持自動類型判斷,即聲明時可以不指定類型,由編譯器判斷。

val a: Int = 1val b = 1 // 系統自動推斷變數類型為Intval c: Int // 如果不在聲明時初始化則必須提供變數類型c = 1 // 明確賦值var x = 5 // 系統自動推斷變數類型為Intx += 1 // 變數可修改

注釋

Kotlin 支持單行和多行注釋，實例如下：

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

與 Java 不同, Kotlin 中的塊注釋允許嵌套。

字元串模板

$ 表示一個變數名或者變數值

$varName 表示變數值

${varName.fun()} 表示變數的方法返回值:

var a = 1// 模板中的簡單名稱：val s1 = "a is $a" a = 2// 模板中的任意表達式：val s2 = "${s1.replace("is", "was")}, but now is $a"

NULL檢查機制

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

//類型後面加?表示可為空var age: String? = "23" //拋出空指針異常val ages = age!!.toInt()//不做處理返回 nullval ages1 = age?.toInt()//age為空返回-1val ages2 = age?.toInt() ?: -1

當一個引用可能為 null 值時, 對應的類型聲明必須明確地標記為可為 null。

當 str 中的字元串內容不是一個整數時, 返回 null:

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

以下實例演示如何使用一個返回值可為 null 的函數:

fun main(args: Array<String>) {
if (args.size < 2) {
print("Two integers expected")
return
}
val x = parseInt(args[0])
val y = parseInt(args[1])
// 直接使用 `x * y` 會導致錯誤, 因為它們可能為 null.
if (x != null && y != null) {
// 在進行過 null 值檢查之後, x 和 y 的類型會被自動轉換為非 null 變數
print(x * y)
}}

類型檢測及自動類型轉換

我們可以使用 is 運算符檢測一個表達式是否某類型的一個實例(類似於Java中的instanceof關鍵字)。

fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 做過類型判斷以後，obj會被系統自動轉換為String類型
return obj.length
}
//在這裡還有一種方法，與Java中instanceof不同，使用!is
// if (obj !is String){
// // XXX
// }
// 這裡的obj仍然是Any類型的引用
return null}

或者

fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在這個分支中, `obj` 的類型會被自動轉換為 `String`
return obj.length}

甚至還可以

fun getStringLength(obj: Any): Int? {
// 在 `&&` 運算符的右側, `obj` 的類型會被自動轉換為 `String`
if (obj is String && obj.length > 0)
return obj.length return null}

區間

區間表達式由具有操作符形式 .. 的 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)}

實例測試

fun main(args: Array<String>) {
print("循環輸出：")
for (i in 1..4) print(i) // 輸出「1234」
println("
----------------")
print("設置步長：")
for (i in 1..4 step 2) print(i) // 輸出「13」
println("
----------------")
print("使用 downTo：")
for (i in 4 downTo 1 step 2) print(i) // 輸出「42」
println("
----------------")
print("使用 until：")
// 使用 until 函數排除結束元素
for (i in 1 until 4) { // i in [1, 4) 排除了 4
print(i)
}
println("
----------------")}

輸出結果：

循環輸出：1234----------------設置步長：13----------------使用 downTo：42----------------使用 until：123----------------

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！