Kotlin语言基础笔记
Kotlin流程控制语句笔记
Kotlin操作符重载与中缀表示法笔记
Kotlin扩展函数和扩展属性笔记
Kotlin空指针安全（null-safety）笔记
Kotlin类型系统笔记
Kotlin面向对象编程笔记
Kotlin委托（Delegation）笔记
Kotlin泛型型笔记
Kotlin函数式编程笔记
Kotlin与Java互操作笔记
Kotlin协程笔记
流程控制语句是编程语言的核心之一。跟java类似，Kotlin有以下的语句。
- 分支语句 if、when
- 循环语句 for、while
- 跳转语句 return、break、continue、throw
1. if表达式
在Kotlin中，if是一个表达式，即它会返回一个值。if作为代码块时，最后一行作为返回值。
package com.dengyin2000.kotlintest1
fun max(x: Int, y: Int): Int {
return if (x > y) {
println("max is $x")
x
}else{
println("max is $y")
y
}
}
fun main(vargs: Array<String>){
val x = if (1 == 1) "abc" else "bcd"
println(x) //打印abc
println(max(1, 2))
//打印max is 2
//打印2
}
注意：Kotlin中没有java的中的2>1?2:1这样的三元表达式。
2. when表达式
Kotlin中的when表达式比java中的简单直接得多。如下：
when (x) {
1 -> print("x == 1")
2 -> print("x == 2")
3, 4 -> print("x == 3 or x == 4")
in 5..9 -> print("x in [5..9]")
is Long -> print("x is Long")
!in 10..20 -> print("x is outside the range")
parseInt(s) -> print("s encodes x")
else -> { // Note the block
print("x is funny")
}
}
像if一样，when的每个分支也可以是一个代码块，它的值就是代码块最后的表达式的值。甚至你可以像写if表达式一样写when：
when {
x.isOdd() -> print("x is odd")
x.isEven() -> print("x is even")
else -> print("x is funny")
}
前面的判断需要返回Boolean类型
3. for循环
Kotlin的for循环与java中的没有什么特别：
for (i in 1..4) {
println(i)
}
val array = arrayOf(1, 2, 3, 4)
for (i in array) {
println(i)
}
for (i in array.indices) {
println(array[i])
}
for ((index, value) in array.withIndex()) {
println("the element at $index is $value")
}
val map = hashMapOf("1" to 1, "2" to 2, "3" to 3)
for (key in map.keys) {
println(key)
}
for (value in map.values) {
println(value)
}
for ((key, value) in map) {
println("the key at $key is $value")
}
4. while循环
while循环也没啥特别的。
5. break和continue
5.1 break
与java没啥区别，略过。
5.2 continue
与java没啥区别，略过。
6. return
在Kotlin中，除了表达式的值，有返回值的函数都要求显示使用return来返回值。
fun sum(x: Int, y: Int): Int {
return x + y
}
fun max(a: Int, b: Int): Int {if (a > b) return a else return b}
fun dive(a: Int, b: Int): Int = a / b
可以直接使用=符号直接返回一个函数的值。
Kotlin中return语句会从最近的函数或匿名函数中返回，但是在Lambda表达式中遇到return，则直接返回最近的外层函数。例如下面两个函数是不同的：
package com.dengyin2000.kotlintest1
fun returnDemo1() {
println(" start " + ::returnDemo1.name)
val intArray = intArrayOf(1, 2, 3, 4, 5)
intArray.forEach {
if (it == 3) {
return
}
println(it)
}
}
fun returnDemo2() {
println(" start " + ::returnDemo2.name)
val intArray = intArrayOf(1, 2, 3, 4, 5)
intArray.forEach (
fun(a: Int) {
if (a == 3) {
return
}
println(a)
}
)
}
fun main(vargs: Array<String>){
returnDemo1()
returnDemo2()
}
结果输出如下：
start returnDemo1
1
2
start returnDemo2
1
2
4
5
returnDemo1函数在遇到3时会直接跳出这个函数，因为是在Lambda表达式中，但是returnDemo2函数却只是忽略了3，因为只是跳出了匿名函数。
7. 标签（label）
在Kotlin中任何表达式都可以用标签来标记，标签的格式为标识符后跟@符号，例如：abc@、jump@。标签可以控制return、break和continue的跳转行为。
上面returnDemo1的例子，如果想修改成跟returnDemo2一样的结果的话，就可以用标签来实现。
fun returnDemo3() {
println(" start " + ::returnDemo3.name)
val intArray = intArrayOf(1, 2, 3, 4, 5)
intArray.forEach here@{
if (it == 3) {
return@here
}
println(it)
}
}
另外，我们也可以使用 隐式的标签更方便，该标签与接收该lambda的函数名相同。如下：
fun returnDemo4() {
println(" start " + ::returnDemo4.name)
val intArray = intArrayOf(1, 2, 3, 4, 5)
intArray.forEach {
if (it == 3) {
return@forEach
}
println(it)
}
}
8. throw表达式
在Kotlin中throw是表达式，它的类型是特殊类型Nothing。该类型没有值。跟C、Java中的void的意思一样。
fun fail(msg: String): Nothing{
throw IllegalArgumentException(msg)
}
fun main(vargs: Array<String>){
println(Nothing::class) //打印class java.lang.Void (Kotlin reflection is not available)
val x = null //x的类型为Nothing?
val l = listOf(null) //l的类型为List<Nothing?>
fail("oops")
}
9. this、super关键字
9.1 this关键字
this关键字持有当前对象的引用。我们可以使用this来引用变量或者成员函数。在类的成员中，this指向的是该类的当前对象。
class Person{
val name = "Jake"
val motherName = "Rose"
fun sayMyName():Person{
println(this.name) //引用变量
println(this.sayMyFatherName()) //引用成员函数
return this //返回当前Person实例
}
fun sayMyFatherName() {
println("Jack")
}
}
fun main(vargs: Array<String>){
val person = Person()
val p = person.sayMyName()
println(person === p)
}
输出：
Jake
Jack
true
在扩展函数或者带接收者的函数字面值中，this表示在左侧传递的接收者参数。
fun Person.sayMyMotherName() = println(this.motherName)
如果this没有限定符，它指的是最内层的包含它的作用域。如果我们想要引用其他作用域中的this，可以使用this@label标签。
class Outer {
val oh = "Oh!"
inner class Inner {
fun m() {
val outer = this@Outer
val inner = this@Inner
val pthis = this
println("outer=" + outer) //outer实例
println("inner=" + inner) //inner实例
println("pthis=" + pthis) //最近的外层作用域，inner实例
println(this@Outer.oh)
val fun1 = hello@ fun String.() {
val d1 = this // 扩展函数，这里的作用域是String
println("d1" + d1)
}
val fun2 = { s: String ->
val d2 = this //Lambda表达式的话，是最近的外层作用域，inner实例
println("d2=" + d2)
}
"abc".fun1()
fun2("abc")
}
}
}
fun main(args: Array<String>) {
Outer().Inner().m()
}
输出：
outer=com.dengyin2000.kotlintest1.Outer@2f0e140b
inner=com.dengyin2000.kotlintest1.Outer$Inner@7440e464
pthis=com.dengyin2000.kotlintest1.Outer$Inner@7440e464
Oh!
d1abc
d2=com.dengyin2000.kotlintest1.Outer$Inner@7440e464
9.2 super关键字
super关键字可以持有指向父类的引用。
package com.dengyin2000.kotlintest1
open class Father{
open val firstName = "Chen"
open val lastName = "Jason"
fun ff() {
println("FFF")
}
}
class Son : Father {
override var firstName = super.firstName
override var lastName = "Jack"
constructor(lastName: String){
this.lastName = lastName
}
fun love() {
super.ff()
println("${super.firstName} ${super.lastName} Love ${this.firstName} ${this.lastName}")
}
}
fun main(args: Array<String>) {
val son = Son("Jack")
son.love()
}
输出
FFF
Chen Jason Love Chen Jack
