【Kotlin】初識Kotlin（二）
【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（面向對象）！
