【Kotlin】初識Kotlin（二）
1、Kotlin的流程控制
流程控制是一門語言中最重要的部分之一，從最經典的if...else...，到之後的switch，再到迴圈控制的for迴圈和while迴圈，都是在開發中離不開的。
之前在第一篇博文中提到了Kotlin中的for迴圈和foreach迴圈，從中可以看出Kotlin在這些流程處理中下了很大一片功夫，也進行了人性化的創新。
接下來我們就從最經典的if ... else ...來講起！
1. if表示式
說起if，我們已經非常熟悉了。也許它的執行效率卻在某些情況下不是最高的，但是它的實用性絕對是最高的！
最傳統的用法我們們不講，我們們講講Kotlin中if創新的用法：
- if表示式當作三元運算子
- if塊
(1) 代替三元運算子
Kotlin在操作符中，沒有三元操作符case ? A : B，但是我們仍然有替代方案，那就是Kotlin中的if (case) A else B。在缺少三元操作符這一塊上，Kotlin使用類似了python的方法，使用if ... else ...來代替！
fun main() {
val flag = 1 == 2
println(if (flag) "true" else "false")
}
反正只要是三元運算子可以做的，if表示式可以做到！
(2) if塊
塊，就是程式碼塊，也就是說if後面可以帶上程式碼塊，這是Java所做不到的
我們舉一個例子
fun main() {
val a = -114
val b = -1919
val max = if (a > b) {
println("$a is larger than $b.")
println("max variable holds value of a.")
a
} else {
println("$b is larger than $a.")
println("max variable holds value of b.")
b
}
println("max = $max")
}
/*
-114 is larger than -1919.
max variable holds value of a.
max = -114
程式已結束,退出程式碼0
*/
我們發現，{}內中的內容我們也執行了。注意的一點是，程式碼塊中最後一行是返回值，這也是lambda的特性之一！
這裡不得不提一句，每次在Java中寫三元運算子的時候，總想寫一些騷操作，比如在三元運算子的時候執行方法，但是偏篇不行，非得寫成4行的if...else...，但是在Kotlin中，方法、程式碼塊都能在if ... else ...中實行了，實在是太方便了！
上述的程式碼可以轉換成這樣的：
fun main() {
val a = -114
val b = -1919
val max = if (a > b) shutA(a,b) else shutB(a,b)
println("max = $max")
}
fun shutA(a: Int, b: Int): Int {
println("$a is larger than $b.")
println("max variable holds value of a.")
return a
}
fun shutB(a: Int, b: Int): Int {
println("$b is larger than $a.")
println("max variable holds value of b.")
return b
}
同樣的，if塊也可以使用if ... else if ... else ...的方式
2. when表示式
這個可是Kotlin獨有的表示式，可以說是switch的增強版，非常的實用！
在上一篇博文講解for迴圈的例子中，我們就簡單的使用了when表示式，現在我們來具體分析一下
我們舉一個簡單的when表示式的例子：
fun main() {
println("輸入符號")
val result = when (val operator = readLine()) {
"+" -> 0
"-" -> 1
"*" -> 2
"/" -> 3
else -> -1
}
println("selected index = $result")
}
我們使用when來進行選擇，()內是選擇的一個物件，這裡選擇的是我們在控制檯寫入的一行字串
對應我們在控制檯寫入的不同的情況，會給reslut變數賦不同的值
再看一種不用when賦值的情況
fun main() {
val a = 12
val b = 5
println("輸入符號 +, -, * , /")
when (val operator = readLine()) {
"+" -> println("$a + $b = ${a + b}")
"-" -> println("$a - $b = ${a - b}")
"*" -> println("$a * $b = ${a * b}")
"/" -> println("$a / $b = ${a / b}")
else -> println("$operator 不是有效符號")
}
}
這種場景就很類似於switch了，只不過 -> 之後可以執行{}區域內的程式碼塊
還有多情況的when選擇，也可以使用,隔開表示多種情況
fun main() {
val n = -1
when (n) {
1, 2, 3 -> println("n is a positive integer less than 4.")
0 -> println("n is zero")
-1, -2 -> println("n is a negative integer greater than 3.")
}
}
我們還可以配合is關鍵字和!is來判斷是我們選擇的物件是否是某個類
fun main() {
val mutableListOf = mutableListOf("String", false, 1, 'c')
mutableListOf.forEach() {
when(it) {
is String -> println("String")
is Boolean -> println("Boolean")
is Char -> println("Char")
else -> println("Int")
}
}
}
當然，我們還可以判斷區間！在剛開始學程式設計的時候，你肯定做過一種題目，就是考試成績的列印，多少分到多少分是什麼擋位，頻繁的if...else...寫膩了，為何不試試愉快的when呢？
fun main() {
println("請輸入你的分數")
when(readLine()?.toInt()) {
in 0 until 60 -> println("不及格")
in 60 until 80 -> println("良好")
in 80 .. 100 -> println("優秀")
else -> println("請輸入正確的成績")
}
}
還有最後一種when無參的情況，也就是when 中的引數可能並非滿足我們的需求，我們可以選擇省略該引數
fun main() {
val tmp = "1"
val tmp2 = "2"
when {
tmp == "1" -> println(tmp)
tmp2 == "2" -> println(tmp2)
}
}
這樣會列印出"1"，到這裡when就終止啦，我們可以通過這樣的使用方式來進行多個選擇
3. break和continue
首先因為while迴圈和大多數語言沒有太大的區別，所以這裡就不介紹了，直接介紹break和continue
break和continue是配合for迴圈、while迴圈使用的控制迴圈執行的兩個關鍵字。之所以我要講這兩個關鍵字，是因為在Kotlin中有了更強大的使用方式
最基本的使用方式我這裡就不多說了，我直接舉一個Kotlin中特有的例子
fun main(args: Array<String>) {
first@ for (i in 1..4) {
second@ for (j in 1..2) {
println("i = $i; j = $j")
if (i == 2)
break@first
}
}
}
/*
i = 1; j = 1
i = 1; j = 2
i = 2; j = 1
*/
看著程式碼，你應該理解了break@one的含義，沒錯，中斷用one@標註的這一層迴圈！
瞬間對Kotlin的處理方式佩服的五體投地。在以往要處理各個巢狀迴圈，因為要控制條件，往往不能這麼寫，但是Kotlin支援給for迴圈、while迴圈新增@標註，然後對標註的迴圈體進行break和continue，實在是太香了！
那麼帶標籤的continue也是一樣的使用方式：
fun main(args: Array<String>) {
here@ for (i in 1..5) {
for (j in 1..4) {
if (i == 3 || j == 2)
continue@here
println("i = $i; j = $j")
}
}
}
/*
i = 1; j = 1
i = 2; j = 1
i = 4; j = 1
i = 5; j = 1
*/
2、Kotlin的函式
首先說明一點，Kotlin的語言邏輯和C++類似，既可以物件導向，也可以程式導向。
我們這裡提及的函式，僅僅是單方面滿足處理需求的，並不是與物件相關的方法
不在物件中的，被稱之為函式
這是 Kotlin 標準庫的連結，可以參閱！
1. 普通函式
Kotlin中變數的定義在第一篇博文中就講了，那麼如果函式中存在引數，一樣的就在()中寫入傳入的引數變數就可以了
值得注意的是Kotlin中是值傳遞，而非引用傳遞，所以更改傳遞進來的區域性變數引數，並不會改變函式之外傳入引數的真實值
例如，一個最簡單的加法函式的編寫：
fun add(a:Int,b:Int) : Int {
return a+b
}
當然，如果函式返回單個表示式，則可以省略函式主體的花括號{ }，並在=符號後指定主體，例如
fun add(a:Int,b:Int) : Int = a+b
當然，再省略一點，可以讓Kotlin自動推斷返回值型別
fun add(a:Int,b:Int) = a+b
2. 中綴函式
中綴函式算是Kotlin的一個特色，使用者可以自定義中綴函式來進行操作
我們之前學習過的區間中的 ..，downTo，until，in等，其實都是中綴函式，包括Map中的to也是中綴函式，之前說是關鍵字，其實並不準確，準確來說是一箇中綴函式
同時，在這裡得提到，與Java不同，Kotlin中沒有按位運河移位運算子，為了解決這種問題，Kotlin官方使用了中綴函式來完成
shl- 符號左移shr- 符號右移ushr- 無符號右移and- 按位和or- 按位或xor- 按位異或inv- 按位反轉
那麼如何建立一個帶有中綴符號的函式呢？有下面幾個限制
- 只有一個引數
- 在方法前必須加infix關鍵字
- 必須是成員方法或者擴充套件方法
例如我在自己寫的一個Student類中，定義一個輸出學號的中綴函式callNumber
class Student() {
infix fun callNumber(number: String) = println("學生的學號為$number")
}
fun main() {
val student = Student()
student callNumber "20203199"
}
/*
學生的學號為20203199
*/
或者我們可以在現有的類中新增中綴函式，例如我在Int型別中新增一個add的中綴函式
infix fun Int.add(tmp:Int) = this+tmp
fun main() {
println(1 add 2)
}
/*
3
*/
3. 函式傳參
在Kotlin中，函式傳參相比Java得到了非常強的優化，使用者體驗非常的好，在我看來甚至比python還要好。
(1) 預設引數
Kotlin中執行函式在編寫的時候就設定預設引數，所謂預設引數就是擁有預設值的引數，例如
fun add(a:Int = 114, b:Int = 1919) :Int {
println("first == $a second == $b")
return a+b
}
fun main() {
println(add())
}
/*
first == 114 second == 1919
2033
*/
這種情況就是使用了預設的a = 114 b = 1919的情況
那麼如果我們僅僅賦值一個引數呢？
fun add(a:Int = 114, b:Int = 1919) :Int {
println("first == $a second == $b")
return a+b
}
fun main() {
println(add(810))
}
/*
first == 810 second == 1919
2729
*/
可以發現Kotlin第一個引數是預設賦值給第一個傳參的
那麼如果我們想給第二個引數b賦值，而不給a賦值呢？
fun add(a:Int = 114, b:Int = 1919) :Int {
println("first == $a second == $b")
return a+b
}
fun main() {
println(add(b=810))
}
/*
first == 114 second == 810
924
*/
使用指定傳參就可以啦！
(2) 傳入函式(方法)
值得注意的是，Kotlin函式中允許傳入函式(方法)這類引數，步驟比Java簡單太多了，只需要指定型別為()即可，例如：
fun add(a:Int = 114, b:Int = 1919, myMethod : ()->Unit ) :Int {
myMethod()
println("first == $a second == $b")
return a+b
}
fun main() {
val res = add(myMethod = { println("this is test method") })
println(res)
}
/*
this is test method
first == 114 second == 1919
2033
*/
這裡傳遞進去的第三個引數就可以是一個方法(函式)，myMethod : ()->Unit 的含義是：myMethod 是一個返回值為Unit型別的函式，Unit相當於Java中的void型別
上述程式碼等同於
fun add(a:Int = 114, b:Int = 1919, myMethod : ()->Unit ) :Int {
myMethod()
println("first == $a second == $b")
return a+b
}
fun main() {
val res = add(myMethod = { testMethod() })
println(res)
}
fun testMethod() = println("this is test method")
也可以這樣寫：
fun add(a:Int = 114, b:Int = 1919, myMethod : ()->Unit ) :Int {
myMethod()
println("first == $a second == $b")
return a+b
}
fun main() {
val res = add() {
println("測試方法")
println("你當然可以在這個方法中寫很多內容！")
}
println(res)
}
也就是說，如果函式中只有一個函式引數，我們可以在括號內寫lambda表示式來表述方法，也可以在括號外寫lambda表示式來表示方法。
如果是兩個函式傳參呢？可以這樣寫
fun add(a:Int = 114, b:Int = 1919, myMethod : ()->Unit, myMethod2:()->Unit ) :Int {
myMethod()
myMethod2()
println("first == $a second == $b")
return a+b
}
fun main() {
val res = add(myMethod = {println("測試1")}, myMethod2 = { println("測試2") })
println(res)
}
或者
fun add(a:Int = 114, b:Int = 1919, myMethod : ()->Unit, myMethod2:()->Unit ) :Int {
myMethod()
myMethod2()
println("first == $a second == $b")
return a+b
}
fun main() {
val res = add(myMethod = {println("測試1")}) {
println("測試2")
}
println(res)
}
這樣的話，()外層的lambda表示式預設是最後一個函式引數的表述實現
(3) 動態引數
什麼叫做動態引數？也就是可以傳遞很多同型別的但是值不同的引數，例如下面的append()函式
fun myAppend(vararg ch:Char): String {
val res = StringBuffer()
ch.forEach {
res.append(it)
}
return res.toString()
}
fun main() {
val myAppend = myAppend('w', 'o', 'o', 'd', 'w', 'h', 'a', 'l', 'e')
println(myAppend)
}
/*
woodwhale
*/
這裡的ch這個引數是不定長的，因為我們使用了vararg修飾
3、Kotlin的更多內容
由於篇幅限制，本篇僅僅講述了Kotlin中的流程控制和函式的部分內容，之後會學習Kotlin的OOP（物件導向）！