基础内容 - 基础部分 - 《小羊的图书馆》

基础语法
条件控制
- if表达式
- when表达式
循环控制

基础语法

定义变量/常量

可变变量定义：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           // 变量可修改

字符串模板

可以在字符串中使用$来表示一个变量名或者变量值

fun test2() {
    var name = "ssssheep"
    println("Hello,$name")
    // 字符串模板中可以写任意表达式
    println("${name.uppercase()}")
}
fun main(args : Array<String>) {
    test2()
}

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

类型检测和自动类型转换

类似于Java中的instance of，可以使用 is 运算符来检测一个表达式是否为某类型的一个实例

fun test3(data :Any) :Int {
    /*
        if (data is String) {
            return data.length
        }
        return null?:-1
    */
    return if (data !is String) {
        // 如果不是String类型，就抛出空指针异常
        null!!
    }else {
        data.length
    }
}
fun main(args : Array<String>) {
//    test1()
//    test2()
    println(test3(1))
}

或者

fun getStringLength(obj: Any): Int? {
  // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
  if (obj is String && obj.length > 0)
    return obj.length
  return null
}

区间

区间表达式由操作符形式..的 rangeTo函数和 in 以及 !in形成

fun test4() {
    for (i in 1..4) {
        println(i)
    }
    println("*************************")
    for (i in 1..10 step 2){
        println(i)
    }
    println("*************************")
    for (i in 10 downTo 1 step 2) {
        println(i)
    }
    println("*************************")
    for (i in 1 until 10) {
        println(i)
    }
}
fun test5(data :Int) {
    for (i in 1 .. data) {
        print("$i ")
    }
}
fun main(args : Array<String>) {
//    test1()
//    test2()
//    println(test3(1))
//    test4()
    test5(5)
}

字符串

和Java一样，String也是不可变的
并且支持三个引号”””包裹起来的字符串，支持多行字符串

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

但是会有缩进和边距
使用trimMargin和trimIndent进行删除

条件控制

if表达式

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

在Kotlin中，没有三元表达式，但是可以将IF表达式的结果赋值给某一个变量

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

可以使用其来实现三元表达式的功能

val c = if (condition) a else b

when表达式

when可以将它的参数和所有的分支条件进行顺序比较，直到某个分支满足条件
类似于其他语言中的switch

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}

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

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

when 也可以结合区间使用

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")
}

用来检测数据的类型

fun test7(data :Any) = when(data) {
    is String -> println("data is String")
    else -> println("data is not String")
}

循环控制

for循环

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

for (item in collection) print(item)

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

fun test8() {
    var arr :Array<Int> = arrayOf(1,2,3,4,5)
    for (i in arr.indices) {
        print("${arr[i]} ")
    }
}

或者使用库函数withIndex

fun test8() {
    var arr :Array<Int> = arrayOf(1,2,3,4,5)
    for ((index,value) in arr.withIndex()) {
        println("index:$index value:$value")
    }
}

while和do…while循环

和其他的语言没有什么不同。不赘述了

从标签处返回

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

fun test9() {
    var arr :Array<Int> = arrayOf(1,2,3,4,5)
    arr.forEach {
        if(it == 1) return
        print("$it ")
    }
    println("test")
}

实际执行的时候，forEach内部的return会直接退出test9这个函数
但是如果我们想要的是让他从表达式内部返回，那么就可以使用标签进行约束

fun test9() {
    var arr :Array<Int> = arrayOf(1,2,3,4,5)
    arr.forEach test@{
        if(it == 1) return@test
        print("$it ")
    }
    println("test")
}

这样就会从lambda表达式内部返回

也可以直接使用一个匿名函数来代替lambda表达式，匿名函数内部的return将从匿名函数中返回

fun test9() {
    var arr :Array<Int> = arrayOf(1,2,3,4,5)
    arr.forEach(fun(item :Int) {
        if(item == 1) return 
        print("$item ")
    })
    println("test")
}