Kotlin的基本语法一

Kotlin 特点

1.兼容性：Kotlin与JDK6完全兼容，保障了Kotlin应用程序可以在较旧的Android设备上运行，并且没有任何问题，Android Studio完全支持Kotlin，并且完全兼容Android工程构建。
2.性能：由于非常相似的字节码结构，Kotlin应用程序的运行速度与Java类似，随着Kotlin对内联函数的支持，使用Lambda表达式的代码通常比用Java写的代码运行的更快。
3.互操作性：Kotlin可与Java进行完全的互操作，允许Kotlin应用程序中使用所有现有的Android库。
4.占用：Kotlin具有非常紧凑的运行时库，可以通过使用ProGuard进一步减少。在实际应用程序中，Kotlin运行时只增加几百个方法以及.apk文件不到100k大小。
5.编译时长：Kotlin支持搞笑的增量编译，所以对于清理构建会有额外的开销。
6.学习曲线：对于java开发人员来说，学习很容易。

基本语法

1.定义变量：一种是只读变量用val修饰；一种是可变变量用var修饰
只读变量(val)：
'''val a: Int = 1''' //赋值并声明类型的
'''val a = 1''' //赋值并自动推断出数据类型的
'''val a: Int''' //没有赋值的类型
可变变量(var)：
'''var a: Int = 1''' //有初始值并声明数据类型的
'''var a = 1''' //有初始值并自动推断出数据类型的
'''var a: Int''' //没有初始值的类型
2.操作符?:当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。
3.操作符!!:非空断言运算符（!!）将任何值转换为非空类型，若该值为空则抛出异常
4.filterNotNull()方法：如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用 filterNotNull 来实现
例如：

val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull()

5.运算符is检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换，相当于java的instanceof。
例如：

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` 在该条件分支内自动转换成 `String`
        return obj.length
    }
    // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
    return null
}

6.不安全的转换操作符as：如果转换是不可能的，转换操作符会抛出一个异常。
例如：

val x: String = y as String

注意，null 不能转换为 String 因该类型不是可空的， 即如果 y 为空，上面的代码会抛出一个异常。 为了匹配 Java 转换语义，我们必须在转换右边有可空类型，就像：

val x: String? = y as String?

7.安全的（可空）转换操作符as?：为了避免抛出异常，可以使用安全转换操作符as?，它可以在失败时返回 null。
例如：

val x: String? = y as? String

注意，尽管事实上 as? 的右边是一个非空类型的String，但是其转换的结果是可空的。
8.if表达式的基本使用

// 传统用法
var max = a 
if (a < b) max = b
// With else 
var max: Int
if (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
}

9.when表达式的基本使用：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x is neither 1 nor 2")
    }
}

when 将它的参数与所有的分支条件顺序比较，直到某个分支满足条件。 when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式， 符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。（像 if 一样，每一个分支可以是一个代码块，它的值是块中最后的表达式的值。）

如果其他分支都不满足条件将会求值 else 分支。 如果 when 作为一个表达式使用，则必须有 else 分支， 除非编译器能够检测出所有的可能情况都已经覆盖了［例如，对于 枚举（enum）类条目与密封（sealed）类子类型］。
如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

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

我们可以用任意表达式（而不只是常量）作为分支条件

when (x) {
    parseInt(s) -> print("s encodes x")
    else -> print("s does not encode x")
}

我们也可以检测一个值在（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")
}

10.For循环:
可以对任何提供迭代器（iterator）的对象进行遍历，这相当于像 C# 这样的语言中的 foreach 循环。语法如下：

for (item in collection) print(item)

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

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

如需在数字区间上迭代，请使用区间表达式:

for (i in 1..3) {
    println(i)
}
for (i in 6 downTo 0 step 2) {
    println(i)
}

对区间或者数组的 for 循环会被编译为并不创建迭代器的基于索引的循环。
如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：

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

或者你可以用库函数 withIndex：

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

11.While循环基本使用:while 与 do..while 照常使用

while (x > 0) {
    x--
}
do {
  val y = retrieveData()
} while (y != null) // y 在此处可见

12.return,Break和continue的基本使用:
return。默认从最直接包围它的函数或者匿名函数返回
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。

val s = person.name ?: return

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() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return // 非局部直接返回到 foo() 的调用者
        print(it)
    }
    println("this point is unreachable")
}

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

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // 局部返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    print(" done with explicit label")
}

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

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // 局部返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    print(" done with implicit label")
}

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

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return  // 局部返回到匿名函数的调用者，即 forEach 循环
        print(value)
    })
    print(" done with anonymous function")
}

请注意，前文三个示例中使用的局部返回类似于在常规循环中使用 continue。并没有 break 的直接等价形式，不过可以通过增加另一层嵌套 lambda 表达式并从其中非局部返回来模拟：

fun foo() {
    run loop@{
        l```istOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // 从传入 run 的 lambda 表达式非局部返回
            print(it)
        }
    }
    print(" done with nested loop")
}

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

return@a 1

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