Kotlin 文件以 .kt 為后綴。
代碼文件的開頭一般為包的聲明:
package com.w3cschool.main
import java.util.*
fun test() {}
class W3cschool{}
kotlin源文件不需要相匹配的目錄和包,源文件可以放在任何文件目錄。
以上例中 test() 的全名是 com.w3cschool.main.test、W3cschool 的全名是 com.w3cschool.main.W3cschool 。
如果沒有指定包,默認(rèn)為 default 包。
有多個包會默認(rèn)導(dǎo)入到每個 Kotlin 文件中:
函數(shù)定義使用關(guān)鍵字 fun,參數(shù)格式為:參數(shù) : 類型
fun sum(a: Int, b: Int): Int { // Int 參數(shù),返回值 Int
return a + b
}
表達(dá)式作為函數(shù)體,返回類型自動推斷:
fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b // public 方法則必須明確寫出返回類型
無返回值的函數(shù)(類似Java中的void):
fun printSum(a: Int, b: Int): Unit {
print(a + b)
}
// 如果是返回 Unit類型,則可以省略(對于public方法也是這樣):
public fun printSum(a: Int, b: Int) {
print(a + b)
}
函數(shù)的變長參數(shù)可以用 vararg 關(guān)鍵字進行標(biāo)識:
fun vars(vararg v:Int){
for(vt in v){
print(vt)
}
}
// 測試
fun main(args: Array<String>) {
vars(1,2,3,4,5) // 輸出12345
}
lambda表達(dá)式使用實例:
// 測試
fun main(args: Array<String>) {
val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
println(sumLambda(1,2)) // 輸出 3
}
可變變量定義:var 關(guān)鍵字
var <標(biāo)識符> : <類型> = <初始化值>
不可變變量定義:val 關(guān)鍵字,只能賦值一次的變量(類似Java中final修飾的變量)
val <標(biāo)識符> : <類型> = <初始化值>
常量與變量都可以沒有初始化值,但是在引用前必須初始化
編譯器支持自動類型判斷,即聲明時可以不指定類型,由編譯器判斷。
val a: Int = 1
val b = 1 // 系統(tǒng)自動推斷變量類型為Int
val c: Int // 如果不在聲明時初始化則必須提供變量類型
c = 1 // 明確賦值
var x = 5 // 系統(tǒng)自動推斷變量類型為Int
x += 1 // 變量可修改
Kotlin 支持單行和多行注釋,實例如下:
// 這是一個單行注釋
/* 這是一個多行的
塊注釋。 */
與 Java 不同, Kotlin 中的塊注釋允許嵌套。
$ 表示一個變量名或者變量值
$varName 表示變量值
${varName.fun()} 表示變量的方法返回值:
var a = 1
// 模板中的簡單名稱:
val s1 = "a is $a"
a = 2
// 模板中的任意表達(dá)式:
val s2 = "${s1.replace("is", "was")}, but now is $a"
Kotlin的空安全設(shè)計對于聲明可為空的參數(shù),在使用時要進行空判斷處理,有兩種處理方式,字段后加!!像Java一樣拋出空異常,另一種字段后加?可不做處理返回值為 null或配合?:做空判斷處理
//類型后面加?表示可為空
var age: String? = "23"
//拋出空指針異常
val ages = age!!.toInt()
//不做處理返回 null
val ages1 = age?.toInt()
//age為空返回-1
val ages2 = age?.toInt() ?: -1
當(dāng)一個引用可能為 null 值時, 對應(yīng)的類型聲明必須明確地標(biāo)記為可為 null。
當(dāng) str 中的字符串內(nèi)容不是一個整數(shù)時, 返回 null:
fun parseInt(str: String): Int? {
// ...
}
以下實例演示如何使用一個返回值可為 null 的函數(shù):
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` 會導(dǎo)致錯誤, 因為它們可能為 null.
if (x != null && y != null) {
// 在進行過 null 值檢查之后, x 和 y 的類型會被自動轉(zhuǎn)換為非 null 變量
print(x * y)
}
}
我們可以使用 is 運算符檢測一個表達(dá)式是否某類型的一個實例(類似于Java中的instanceof關(guān)鍵字)。
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 做過類型判斷以后,obj會被系統(tǒng)自動轉(zhuǎn)換為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` 的類型會被自動轉(zhuǎn)換為 `String`
return obj.length
}
甚至還可以
fun getStringLength(obj: Any): Int? {
// 在 `&&` 運算符的右側(cè), `obj` 的類型會被自動轉(zhuǎn)換為 `String`
if (obj is String && obj.length > 0)
return obj.length
return null
}
區(qū)間表達(dá)式由具有操作符形式 .. 的 rangeTo 函數(shù)輔以 in 和 !in 形成。
區(qū)間是為任何可比較類型定義的,但對于整型原生類型,它有一個優(yōu)化的實現(xiàn)。以下是使用區(qū)間的一些示例:
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 函數(shù)排除結(jié)束元素
for (i in 1 until 10) { // i in [1, 10) 排除了 10
println(i)
}
fun main(args: Array<String>) {
print("循環(huán)輸出:")
for (i in 1..4) print(i) // 輸出“1234”
println("\n----------------")
print("設(shè)置步長:")
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 函數(shù)排除結(jié)束元素
for (i in 1 until 4) { // i in [1, 4) 排除了 4
print(i)
}
println("\n----------------")
}
輸出結(jié)果:
循環(huán)輸出:1234
----------------
設(shè)置步長:13
----------------
使用 downTo:42
----------------
使用 until:123
----------------
更多建議: