【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（面向物件）！
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/431465.html
標籤：其他