2.1 Kotlin基础

1. 变量

1.1 变量的自动推导

• java 中基本数据类型为小写，而 Kotlin 中是大写，即是对象数据类型，即是一个类
• 其中抽象类为 Number

val a = 10
val b = "abc"
val c = 20.5
//println(a+b)          // 类型推导报错
println("$a$b")         // 10abc
println(b+a)            // abc10
println(a+c)            // 30.5
println("a = "+ a)      // a = 10
println("a = $a")       // 10

• 显式转换方式
• .toInt()

var numA: Int = 97
println(numA.toByte())
println(numA.toShort())
println(numA.toInt())
println(numA.toLong())
println(numA.toFloat())
println(numA.toDouble())
println(numA.toChar())
println(numA.toString())

1.2 val, var, const val

• val：不可修改变量
  • 对于对象，是引用不可变，而不是值不可变
• var：可修改变量
• const val：常量
  • 只能用于
    • 顶层声明
    • object修饰的类中
    • 伴生对象中

const val f = 10
fun main(){

    val a: Int = 10     // 立即初始化
    val b = 5           // 推导出类型
    val c : Float       // 没有初始化的时候，必须声明类型，使用前赋值
    val list = mutableListOf(1, 2, 3) 
    list.add(4)
//    var d  报错
//    const val e = 10  报错
    c = 12.5F
    println("$a \n$b \n$c \n$f \n")
}

2. 函数

fun main(){
    val sum1 = add1(2,5)
    val sum2 = add2(2,5)
    val sum3 = add3(2,5)
    println(sum1)
    println(sum2)
    println(sum3)
}

fun add1(num1: Int, num2: Int): Int{
    return num1 + num2
}
fun add2(num1: Int, num2: Int): Int = num1 + num2   // 一行时可以直接使用 =
fun add3(num1: Int, num2: Int) = num1 + num2   // 进一步简化
val add4 = fun(num1: Int, num2: Int) = num1 + num2 // 匿名函数

3. 逻辑控制

3.1 if 语句

fun largerNum1(num1: Int, num2: Int): Int{
    var num : Int
    if(num1 > num2){
        num = num1
    } else {
        num = num2
    }
    return num
}
fun largerNum2(num1: Int, num2: Int): Int{  // if语句每个条件中最后一行代码就是返回值
    val num = if(num1 > num2){
         num1
    } else {
        num2
    }
    return num
}
fun largerNum3(num1: Int, num2: Int): Int{  // 省略 val
    return if(num1 > num2){
        num1
    } else {
        num2
    }
}

fun largerNum4(num1: Int, num2: Int) = if(num1 > num2) {    // 相当于一行，简写
    num1
}else{
    num2
}

fun largerNum5(num1: Int, num2: Int) = if(num1 > num2) num1 else num2 

• if也可以视作三元运算符

val a = 10
val b = if(a > 5) 15 else 5
val c = if(a < 5) 15 else 5
println("$b \t $c")

3.2 when 语句

• 类似 switch 语句，但更强大

1. 与逗号一起实现 switch 功能

when(2){
    1,2,3 -> {			// 可以有括号，也可以没有
        println(123)
    }
    4 -> println(4)
    5 -> println(5)
    else -> println(0)
}

2. 检查值是否存在于集合或数组中

val arrayList = arrayOf(1,2,3,4,5)
when(1){
    in arrayList.toIntArray() -> {					// in 判断是否在集合内
        println("1 存在于 arrayList数组中")
    }
    in 0 .. 10 -> println("1 属于于 0~10 中")   	 // .. 表示闭区间
    !in 5 .. 10 -> println("1 不属于 5~10 中")
    else -> {
        println("都不存在")
    }
}

3. 检查类型

// 智能转换
var a: Int = 2
when(a){
    !is Int -> {
        println("$a 不是一个Int类型的值")
    }
    else -> {
        a = a.shl(2)		// 右移
        println("a => $a")
    }
}

3.3 for 语句

1. 普通循环

for(i in 1 .. 10){              // [1, 10]
    println(i)
}

for(i in 1 until 10){           // [1, 10)
    println(i)
}

for(i in 10 downTo 1){          // [1, 10)　逆序
    println(i)
}

for(i in 10 downTo 1 step 2){
    println(i)
}

2. 迭代

// 字符串
for (i in "abcdefg"){
    println(i)
}

// 数组
val arrayList = arrayOf(10,20,30,40,50)
for (i in arrayList){
    println(i)
}

// 数组 indices
for (i in arrayList.indices){
    println("arrayList[$i] => " + arrayList[i])
}

// 数组 withIndex
for ((index,value) in arrayList.withIndex()){
    println("index => $index \t value => $value")
}

4. 空指针检查

4.1 可空类型变量

1. java/c++ 中的空指针

public void doStudy(Study study){
    if(study != null){
        study.readingBooks();
        study.doHomeworks();
    }
}

2. Kotlin 中的可空类型

• 在 kotlin 中，普通变量默认不能为空
• 因此提出可空类型

var nullA : Int? = 12
val nullB : Int? = 13

nullA = null

if(nullA == null){
    println("nullA = $nullA")
}

4.2 可空类型的判断 ?. 运算符

fun main(){
    val s = Study()
    val sList = listOf(s, null)
    for(s in sList){
//        doStudy(s)                // 无法处理 null
        doStudyNull(s)
        doStudyNullIfElse(s)
    }
}

fun doStudy(study: Study){
    study.readingBooks()
    study.doHomework()
}

fun doStudyNullIfElse(study: Study?){   // if-else 判断可空
    if(study!=null){
        study.readingBooks()
        study.doHomework()
    }
}

fun doStudyNull(study: Study?){         // ?. 判断可空
    study?.readingBooks()
    study?.doHomework()
}

class Study{
    fun readingBooks(){ println("reading.")}
    fun doHomework(){ println("doing.")}
}

4.3 可空类型的应用

1. 可空类型的函数和 ?: 运算符

val str1 = "123"
val str2 : String? = null

fun func1(str : String?) : Int? {     // 可空参数 和 可空返回值
    return str?.length
}

fun func2(str : String?) : Int {    
    return str?.length ?: 0			  // ?: 运算符
}

println(func1(str1))
println(func1(str2))
println(func2(str2))

2. let 操作符

• 作用：配合符号 ?. 忽略容器中的 null

fun doStudy(study: Study?){
    study?.let{
        stu -> stu.doHomework()
    }
}

fun doStudy(study: Study?){
    study?.let{ it.doHomework() } // it 关键字简化
}

3. !! 操作符

• 对于一个全局非空变量
• 如果在主函数里面判定非空，并调用函数
• 然后在调用函数里面如果不判空，则会报错，因为不知道已经判空了
• 此时可以加上 !! 操作符，表示非空断言，即确定不会为空，不需要检查，如果出错抛出异常，后果自己承担

var str : String? = "hello"

fun main() {
    if(str != null){
        printUpperCase()
    }
}
fun printUpperCase() {
//    val upperCase = str.uppercase()   // 报错，不知道已经判空
    val upperCase = str!!.uppercase()
    println(upperCase)
}

4. as? 操作符

• 功能：类型转换
• 转换失败时
  • as? 返回 null
  • as 抛出异常

val num1 : Int? = "Koltin" as Int  // 会抛出ClassCastException异常
println("nun1 = $num1")

val num2 : Int? = "Koltin" as? Int
println("nun2 = $num2")

5. 链式调用

【暂时没get到】

class Test{
    class Builder{
        private var name : String? = "Tom"
        private var age : Int? = 0
        private var sex : String? = "男"

        fun setName(name : String) : Builder?{
            this.name = name
            return this
        }
        fun setAge(age : Int) : Builder?{
            this.age = age
            return this
        }
        fun setSex(sex: String?) : Builder?{
            this.sex = sex
            return this
        }
        override fun toString(): String {
            return "Builder(name=$name, age=$age, sex=$sex)"
        }
    }
}

fun main(args: Array<String>) {
    val builder : Test.Builder? = Test.Builder().setName("Lily")?.setSex("nv")?.setAge(10)
    println(builder.toString())   // 输出为：Builder(name=Lily, age=10, sex=女)
}