Kotlin 基础语法-01

Kotlin 基础语法

Kotlin 文件以 .kt 为后缀。

函数定义

函数定义使用关键字 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           // 变量可修改

字符串模板

表示一个变量名或者变量值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}

区间

区间表达式由具有操作符形式 .. 的 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 基本数据类型

Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于Java的是，字符不属于数值类型，是一个独立的数据类型。

类型 位宽度 Double 64 Float 32 Long 64 Int 32 Short 16 Byte 8

字面常量

下面是所有类型的字面常量：
- 十进制：123
- 长整型以大写的 L 结尾：123L
- 16 进制以 0x 开头：0x0F
- 2 进制以 0b 开头：0b00001011
- 注意：8进制不支持

Kotlin 同时也支持传统符号表示的浮点数值：
- Doubles 默认写法: 123.5, 123.5e10
- Floats 使用 f 或者 F 后缀：123.5f

你可以使用下划线使数字常量更易读：

val oneMillion = 1_000_000val creditCardNumber = 1234_5678_9012_3456Lval socialSecurityNumber = 999_99_9999Lval hexBytes = 0xFF_EC_DE_5Eval bytes = 0b11010010_01101001_10010100_10010010

比较两个数字

三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

fun main(args: Array<String>) {    val a: Int = 10000    println(a === a) // true，值相等，对象地址相等    //经过了装箱，创建了两个不同的对象    val boxedA: Int? = a    val anotherBoxedA: Int? = a    //虽然经过了装箱，但是值是相等的，都是10000    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样    println(boxedA == anotherBoxedA) // true，值相等}

类型转换

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。

val b: Byte = 1 // OK, 字面值是静态检测的val i: Int = b // 错误//我们可以代用其toInt()方法。val b: Byte = 1 // OK, 字面值是静态检测的val i: Int = b.toInt() // OK

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): BytetoShort(): ShorttoInt(): InttoLong(): LongtoFloat(): FloattoDouble(): DoubletoChar(): Char

有些情况下也是可以使用自动类型转化的，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val l = 1L + 3 // Long + Int => Long

位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)shr(bits) – 右移位 (Java’s >>)ushr(bits) – 无符号右移位 (Java’s >>>)and(bits) – 与or(bits) – 或xor(bits) – 异或inv() – 反向

操作符 is

is 运算符检测⼀个表达式是否某类型的⼀个实例。 如果⼀个不可变的局部变量或属性已经判断出为某类型，那么检测后的分⽀中可以直接当作该类型使⽤，⽆需显式转换：

fun getStringLength(obj: Any): Int? {// `obj` 在 `&&` 右边⾃动转换成 `String` 类型if (obj is String && obj.length > 0) ｛    return obj.length}    return null}

字符

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号”包含起来的。比如普通字符 ‘0’，’a’。

fun check(c: Char) {    if (c == 1) { // 错误：类型不兼容        // ……    }}

字符字面值用单引号括起来: ‘1’。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\’、\”、\\ 和 $。 编码其他字符要用 Unicode 转义序列语法：’\uFF00’。
我们可以显式把字符转换为 Int 数字：

fun decimalDigitValue(c: Char): Int {    if (c !in '0'..'9')        throw IllegalArgumentException("Out of range")    return c.toInt() - '0'.toInt() // 显式转换为数字}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

布尔

布尔用 Boolean 类型表示，它有两个值：true 和 false。
若需要可空引用布尔会被装箱。
内置的布尔运算有：

|| – 短路逻辑或&& – 短路逻辑与! - 逻辑非

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。
数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array<String>) {    //[1,2,3]    val a = arrayOf(1, 2, 3)    //[0,2,4]    val b = Array(3, { i -> (i * 2) })    //读取数组内容    println(a[0])    // 输出结果：1    println(b[1])    // 输出结果：2}

如上所述，[] 运算符代表调用成员函数 get() 和 set()。
注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。
除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)x[0] = x[1] + x[2]

字符串

和 Java 一样，String 是可不变的。方括号 [] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历：

for (c in str) {    println(c)}

Kotlin 支持三个引号 “”” 扩起来的字符串，支持多行字符串，比如：

fun main(args: Array<String>) {    val text = """    多行字符串    多行字符串    """    println(text)   // 输出有一些前置空格}

String 可以通过 trimMargin() 方法来删除多余的空白。

fun main(args: Array<String>) {    val text = """    |多行字符串    |菜鸟教程    |多行字符串    |Runoob    """.trimMargin()    println(text)    // 前置空格删除了}

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(“>”)。

字符串模板

字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模板表达式以美元符（$）开头，由一个简单的名字构成:

fun main(args: Array<String>) {    val i = 10    val s = "i = $i" // 求值结果为 "i = 10"    println(s)}

或者用花括号扩起来的任意表达式:

fun main(args: Array<String>) {    val s = "runoob"    val str = "$s.length is ${s.length}" // 求值结果为 "runoob.length is 6"    println(str)}

原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：

fun main(args: Array<String>) {    val price = """    ${'$'}9.99    """    println(price)  // 求值结果为 $9.99}

Kotlin 条件控制

IF 表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

// 传统用法var max = a if (a < b) max = b// 使用 else var max: Intif (a > b) {    max = a} else {    max = b}// 作为表达式val max = if (a > b) a else b

我们也可以把 IF 表达式的结果赋值给一个变量。

val max = if (a > b) {    print("Choose a")    a} else {    print("Choose b")    b}

这也说明我也不需要像Java那种有一个三元操作符，因为我们可以使用它来简单实现：

val c = if (condition) a else b

实例

fun main(args: Array<String>) {    var x = 0    if(x>0){        println("x 大于 0")    }else if(x==0){        println("x 等于 0")    }else{        println("x 小于 0")    }    var a = 1    var b = 2    val c = if (a>=b) a else b    println("c 的值为 $c")}

输出结果为：x 等于 0c 的值为 2

使用区间

使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：
实例

fun main(args: Array<String>) {    val x = 5    val y = 9    if (x in 1..8) {        println("x 在区间内")    }}输出结果为：x 在区间内

When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。

when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {    1 -> print("x == 1")    2 -> print("x == 2")    else -> { // 注意这个块        print("x 不是 1 ，也不是 2")    }}fun cases(obj: Any) {    when (obj) {        1 -> println("One")        "Hello" -> println("Greeting")        is Long -> println("Long")        !is String -> println("Not a string")        else -> println("Unknown")    }}

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。
如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

when (x) {    0, 1 -> print("x == 0 or x == 1")    else -> print("otherwise")}

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

when (x) {    in 1..10 -> print("x is in the range")    in validNumbers -> print("x is valid")    !in 10..20 -> print("x is outside the range")    else -> print("none of the above")}

另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意： 由于智能转换，你可以访问该类型的方法和属性而无需 任何额外的检测。

fun hasPrefix(x: Any) = when(x) {    is String -> x.startsWith("prefix")    else -> false}

when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {    x.isOdd() -> print("x is odd")    x.isEven() -> print("x is even")    else -> print("x is funny")}

实例

fun main(args: Array<String>) {    var x = 0    when (x) {        0, 1 -> println("x == 0 or x == 1")        else -> println("otherwise")    }    when (x) {        1 -> println("x == 1")        2 -> println("x == 2")        else -> { // 注意这个块            println("x 不是 1 ，也不是 2")        }    }    when (x) {        in 0..10 -> println("x 在该区间范围内")        else -> println("x 不在该区间范围内")    }}输出结果：x == 0 or x == 1x 不是 1 ，也不是 2x 在该区间范围内

when 中使用 in 运算符来判断集合内是否包含某实例：

fun main(args: Array<String>) {    val items = setOf("apple", "banana", "kiwi")    when {        "orange" in items -> println("juicy")        "apple" in items -> println("apple is fine too")    }}输出结果：apple is fine too

Kotlin 循环控制

For 循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

for (item in collection) print(item)

循环体可以是一个代码块:

for (item: Int in ints) {    // ……}

如上所述，for 可以循环遍历任何提供了迭代器的对象。
如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：

for (i in array.indices) {    print(array[i])}

注意这种”在区间上遍历”会编译成优化的实现而不会创建额外对象。
或者你可以用库函数 withIndex：

for ((index, value) in array.withIndex()) {    println("the element at $index is $value")}

包含

if (x !in 0..array.size - 1)println("Out: array has only ${array.size} elements. x = ${x}")//Check if a collection contains an object:if ("aaa" in array) // collection.contains(obj) is calledprintln("Yes: array contains aaa")

实例
对集合进行迭代：

fun main(args: Array<String>) {    val items = listOf("apple", "banana", "kiwi")    for (item in items) {        println(item)    }    for (index in items.indices) {        println("item at $index is ${items[index]}")    }}输出结果：applebananakiwiitem at 0 is appleitem at 1 is bananaitem at 2 is kiwi

while 与 do…while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {  //循环内容}

do…while 循环 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {       //代码语句}while(布尔表达式);do { //代码语句 }while(布尔表达式);实例fun main(args: Array<String>) {    println("----while 使用-----")    var x = 5    while (x > 0) {        println( x--)    }    println("----do...while 使用-----")    var y = 5    do {        println(y--)    } while(y>0)}输出结果：54321----do...while 使用-----54321

返回和跳转

Kotlin 有三种结构化跳转表达式：
- return。默认从最直接包围它的函数或者匿名函数返回。
- break。终止最直接包围它的循环。
- continue。继续下一次最直接包围它的循环。
在循环中 Kotlin 支持传统的 break 和 continue 操作符。

fun main(args: Array<String>) {    for (i in 1..10) {        if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环        println(i)        if (i>5) break   // i 为 6 时 跳出循环    }}输出结果：12456

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签（label）来标记。 标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。 要为一个表达式加标签，我们只要在其前加标签即可。

loop@ for (i in 1..100) {    // ……}

现在，我们可以用标签限制 break 或者continue：

loop@ for (i in 1..100) {    for (j in 1..100) {        if (……) break@loop    }}

标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代。
标签处返回

Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。 最重要的一个用途就是从 lambda 表达式中返回。回想一下我们这么写的时候：

fun foo() {    ints.forEach {        if (it == 0) return        print(it)    }}

这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。

fun foo() {    ints.forEach lit@ {        if (it == 0) return@lit        print(it)    }}

现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo() {    ints.forEach {        if (it == 0) return@forEach        print(it)    }}

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回

fun foo() {    ints.forEach(fun(value: Int) {        if (value == 0) return        print(value)    })}

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@a 1

意为”从标签 @a 返回 1”，而不是”返回一个标签标注的表达式 (@a 1)”。