Kotlin 基礎語法
Kotlin 文件以 .kt 為后綴。
包聲明
代碼文件的開頭一般為包的聲明：
package com.runoob.main
import 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 + b public 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 = 1 val b = 1 // 系統自動推斷變量類型為Int val c: Int // 如果不在聲明時初始化則必須提供變量類型 c = 1 // 明確賦值 var x = 5 // 系統自動推斷變量類型為Int x += 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() //不做處理返回 null val ages1 = age?.toInt() //age為空返回-1 val 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("\n----------------")
print("設置步長：")
for (i in 1..4 step 2) print(i) // 輸出“13”
println("\n----------------")
print("使用 downTo：")
for (i in 4 downTo 1 step 2) print(i) // 輸出“42”
println("\n----------------")
print("使用 until：")
// 使用 until 函數排除結束元素
for (i in 1 until 4) { // i in [1, 4) 排除了 4
print(i)
}
println("\n----------------")
}
輸出結果：
循環輸出：1234 ---------------- 設置步長：13 ---------------- 使用 downTo：42 ---------------- 使用 until：123 ----------------