目录

• 一、基础语法
  • 1.1 常见数据类型
  • 1.2 变量
    • 1.2.1 变量声明
    • 1.2.2 类型推断
    • 1.2.3 Null 安全
    • 1.2.4 面向对象语言
  • 1.3 流程控制
    • 1.3.1 if 表达式
    • 1.3.2 When 表达式
    • 1.3.3 For 循环
    • 1.3.4 While 循环
• 二、函数与 lambda 表达式
  • 2.1 函数声明
  • 2.2 函数类型
    • 2.2.1 示例引入
    • 2.2.2 Koltin 函数类型
    • 2.2.3 函数引用
    • 2.2.4 高阶函数
  • 2.3 lambda 表达式
    • 2.3.1 lambda 表达式的概念
    • 2.3.2 lambda 表达式的写法演变过程
    • 2.3.3 lambda 表达式自调用
    • 2.3.4 总结
• 三、接口、类与对象
  • 3.1 类
    • 3.1.1 构造函数
    • 3.1.2 init 代码块
    • 3.1.3 成员变量
    • 3.1.4 继承
  • 3.2 接口
  • 3.3 数据类
  • 3.4 内部类
  • 3.5 密封类
  • 3.6 伴生对象
  • 3.7 可见性修饰符
• 四、 Kotlin 的一些其它特性
  • 4.1 函数参数默认值
  • 4.2 本地函数（嵌套函数）
  • 4.3 try-catch 表达式
  • 4.4 == 和 ===
  • 4.5 拓展函数和拓展属性
  • 4.6 Top-level
  • 4.7 by lazy （委托）
• 五、 More

一、基础语法

Koltin 是一种静态强类型语言，它要求在编译时确定变量类型，并在运行时严格执行类型检查。

1. 声明变量时必须指定变量类型，无法隐式地将不同类型的值分配给变量。
2. 有助于减少类型错误，使得代码更加稳健和可维护。

1.1 常见数据类型

Byte、 Short、 Int、 Long、 Float、 Double、 Char、 Boolean、 String

特殊的类型： Unit， 类似 java 中的 Void， 函数或者表达式没有返回值时用 Unit

无 java 中的 int、 Integer 等，避免装箱拆箱的性能损耗。
在某些情况下，Kotlin 仍然需要进行装箱拆箱操作，例如将基本类型的值传递给需要对象类型的函数时，或者将基本类型的值放入集合或数组中时。

转换：

3.toFloat()

val a = 5.6f
a.toInt()

字符串 String

val name： String = "Lucy"

// 可循环
for (c in name) {

}

// 可拼接
println(name + "abc") // Lucyabc

// 字面值
val s = "Hello, world!\n"  // 反斜杠转义

// 三引号内部不转义，可以包含任何字符，包括换行符
val text = """
    for (c in "abc") {
        println(c)
    }
"""

// 字符串模板
val name = "James"
println("$name is a basketball player!")

// 用 ${} 引用表达式
println("$name 这个单词的长度是 ${name.length}")

1.2 变量

1.2.1 变量声明

var um: Int = 0  // 使用 var 声明一个可读可写的变量
val name: String = "Jimy"  // 使用 val 声明一个引用不可变的变量,对象成员可变，Java 中 final 的效果, 尽可能采用 val 声明变量。

1.2.2 类型推断

val name = "Lucy"  // name 可以推断出 name 是 String  类型
name.uppercase()  // 正确

// fails to compile
name.inc() // inc() 是 Int 类型的的运算浮， String 类型无法调用

1.2.3 Null 安全

可空类型

// Fails to complie
val name: String = null

要使变量持有 null 值，它必须是可为 null 类型，在变量类型后面加上一个 ? 后缀。

val name: String? = null  

指定 String? 类型后，可以为 name 赋予 String 值或者 null

安全调用
安全调用 ?.
非空断言 !!

// java
String name = "Lucy"
if (name != null ) {
    name.toUpperCase()
}

// Koltin
val name: String? = null 
name?.uppercase()  // name 不为 null 时执行方法调用
name!!.uppercase()  // name 为 null 时，抛出异常

多层判断可以链式调用。

Elvis操作符

// java
int nameLength = name!=null ? name.length : -1

// Koltin
val nameLength = name?.length?:-1

注意： 上面 Kotlin 版本中 nameLength 类型为 Int。

val name： String? = "Lucy"
val length = name?.length

上面这段代码中 length 是什么类型？ ----- Int?

1.2.4 面向对象语言

Any ---- 类似于 java 中的 Object， 所有非空类型的根类型
Any? ---- 所有类型的根类型。 自然也是 Any 的跟类型。

Nothing ---- 所有类型的最底层，包含一个值 null

1.3 流程控制

1.3.1 if 表达式

// 传统写法
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}

// 表达式写法
var max: Int = if (a > b) a else b

注意： if 作为表达式而不是语句时，需要有 else 分支。

1.3.2 When 表达式

when(x) {
    1 -> { println("x == 1") }
    is Int -> { println("x is a Int") }
    2, 3 -> {println("x == 2 or x == 3")}  // 多个分支条件放在一起用 , 隔开
    else -> { println("x maybe a string") }
}

多个分支条件放在一起用 , 隔开。
when 将它的参数与所有的分支条件顺序比较，直到某个分支满足条件（匹配第一个满足条件的分支）。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式， 符合条件的分支的值就是整个表达式的值。必须有 else 分支， 除非编译器能够检测出所有的可能情况都已经覆盖了。（例如 枚举 或者 密封类子类。

When 进阶用法，不提供参数：

if (age > 60) {
    println("老年人，可以享受6折优惠")
} else if (age > 0) { 
    if (identity is Student) {
        println("学生，可以享受半价优惠")
    } else {
        println("需要全价")
    }
} else {
    throw AgeIlligalException("age must be greater than 0")
}