Kotlin学习笔记（2）---程序的逻辑控制

Kotlin学习笔记（2）—程序的逻辑控制及运算符

在进行一些业务逻辑的处理或者实现一些算法的时候，避免不了地需要使用诸如选择判断，循环控制之类的逻辑。

1.条件语句

在Kotlin中，条件语句主要有两种实现方式：if和when

1.1 if表达式：

在Kotlin中，if语句和Java中很像，在Kotlin中，if语句是可以有返回值的，这个返回值就是每个if条件的最后一行代码。还是之前的那个例子，比较两个数中比较小的那个数，在Kotlin中，我们可以这样写：

fun getMin(num1:Int,num2: Int):Int{
    var value = 0
    if (num1<num2){
        value = num1
    }else{
        value = num2
    }
    return value
}

这里if语句的用法与java中完全一致。然而我们上边提到了在Kotlin中，if语句是有返回值的，返回值就是if语句的最有一行。所以我们就可以将上方的getMin()方法修改成这样：

fun getMin(num1:Int,num2: Int):Int{
    return if (num1<num2){
         num1
    }else{
         num2
    }
}

直接返回一个if语句的返回值即可。到这里你是不是觉得已经精简了很多？用点子智慧嘛
想想我们之前提到的语法糖，是不是有灵感了，哈哈哈

fun getMin(num1:Int,num2: Int)=if (num1<num2){
         num1
    }else{
         num2
    }

然后简化一下就成了这样：

fun getMin(num1:Int,num2: Int)=if (num1<num2) num1 else num2

我的老天鹅，这简直是天壤之别。

1.2 when语句

when对标的其实是Java中的switch，但它更加是switch的升级版，它支持更多的参数类型。我们用一个简单的例子看看，用if语句实现：

fun getColor(name:String) = if(name == "banana"){
    "yellow"
} else if (name == "apple"){
    "red"
}else if(name == "peach"){
    "pink"
}else{
    "null"
}

如果用java的switch语句来写的话，就需要分很多的case，然后每个case结束之后还需要添加break来进行case的结束，否则将会继续进行判断。
而在Kotlin中，我们就可以这样写：

fun getColor(name:String) = when(name){
    "banana"->"yellow"
    "apple"->"red"
    "peach"->"pink"
    else->"black"
}

是不是简单明了？
还有一种when中不加参数的写法：

fun getColor(name:String) = when{
    name == "banana"->"yellow"
    name == "apple"->"red"
    name == "peach"->"pink"
    else->"black"
}

在Kotlin中，“==” 代表了判断内容相等 ，“ ===”号代表了判断内存地址相等
这样的话，可能有些人会觉得没有必要。但是如果有这样一个场景，所有b开头的东西，我们都想让他变成黄色，那么就可以这样写：

fun getColor(name:String) = when{
    name.startsWith("b") ->"yellow"
    name == "apple"->"red"
    name == "peach"->"pink"
    else->"black"
}

2 .循环语句

在Java中，有两种循环语句：for循环和while循环。而在Kotlin中，也提供了for循环和while循环，其中while循环在语法上与java中的while循环是一样的，这里就不做赘述。我们一起看看for循环。

2.1 for循环

java中的for循环有for-i循环和for-each循环。在Kotlin中，舍弃了for-i循环，而大大加强了for-each循环，形成了Kotlin独有的for-in循环。Kotlin的for-each循环的参数都需要实现Iterator迭代器。
首先我们知道，对于一个循环来说最重要的就是循环区间。而在Kotlin中，区间有一种特殊的表示方法：

0..10

这句话代表了从0到10的闭区间，即[0,10]，知道区间的写法之后，就可以来写我们的for-in循环了，我们试着输出一下从0到10所有的数：

 for (i in 0..10){
        println(i)
    }

在日常情况下，我们用到最多的是左闭右开区间，例如一个长度为10的数组的下标范围是0-9.即[0,9）。在Kotlin中，可以用until关键字来标识一个左闭右开的区间。那么如果我们想要输出0-9的话，就可以写成：

  for (i in 0 until 10){
        println(i)
    }

然后有时候，我们会通过操作i来控制循环，在上面的两个例子中，i都是一直在累加的，而我们有时候需要将i进行i=i+2,i=i+3等运算，那我们就可以这样写：

    for (i in 0 until 10 step 3){
        println(i)
    }

如果我们要用到一个降序区间的话，可以这样写：

   for (i in 10 downTo  0 step 3){
        println(i)
    }

当我们需要知道元素的下标时，则可以使用array.withIndex()方法，举个🌰：

fun main(args:Array<String>) {
 val array  = arrayOf("a","b","c","d","e","f")

    for ((index,value) in array.withIndex()){
        println("$index -> $value")
    }
}

但其实这里这个匿名对象（index,value)其实是一个叫做indexValue的对象，所以也可以写成这样：

fun main(args:Array<String>) {
 val array  = arrayOf("a","b","c","d","e","f")

    for (indexValue in array.withIndex()){
        println("${indexValue.index} -> ${indexValue.value}")
    }
}

当我们需要跳过循环时，可以使用continue关键字，当需要跳出循环时，可以使用break关键字。

fun main(args:Array<String>) {
 val array  = arrayOf("a","b","c","d","e","f")

    for (word in array){
        if (word == "c")continue
        println(word)
        if (word == "e")break
    }
}

执行结果如下：

2.2 while循环

Kotlin中while循环与Java中用法已知，也存在while与do-while循环两种。

3.运算符

3.1 运算符重载

在kotlin中，任何类都可以定义或者重载父类的基本运算符。在定义时应通过运算符对应的具名函数来定义，如定义 “+”，则需要定义plus方法。举个🌰：

    class Book(var num: Int) {
        operator fun plus(other: Book): Book {
            return Book(num + other.num)
        }
        override fun toString(): String {
            return "num is $num"
        }
}

fun main() {
    val b1 = OperatorTest.Book(1)
    val b2 = OperatorTest.Book(3)

    println(b1 + b2)
}

我们给Book类定义操作符“+”，让两个Book对象在进行“+”操作时 ，运算属性num的和，生成新的Book对象。
代码执行结果如下：

需要注意的是：

• 在进行运算符重载时，对参数的个数有明确的要求，但对参数的类型与返回值的类型没有要求
• 在进行运算符重载时，只能重载已有的运算符如“+，”-“等，不能定义未被父类定义的运算符。

3.2 中缀表达式

当一个函数只有一个参数的时候，可以使用infix关键字去修饰这个方法，将其转换为一个中缀表达式。
举个🌰：

 class Book(var num: Int) {
        infix fun seal(count: Int):Book{
            return Book(num-count)
        }
        override fun toString(): String {
            return "num is $num"
        }
}

fun main() {
    val b2 = OperatorTest.Book(3)
    print(b2 seal 1)
}

在这里我们定义了一个seal方法，接收一个int类型的参数，返回一个Book类型的值。代码执行结果如下：

4.异常捕获

Kotlin中try-cache也是表达式，可以在末尾返回语句。除此以外与Java语言中的用法基本相同

5.参数传递

5.1 具名参数

当调用函数时，显示的指定形参对应传入的参数时，就叫做具名参数，例如：

fun main(args:Array<String>) {

    println(sum(num1 = 1,num2 = 2))
}

fun sum(num1: Int,num2: Int):Int{
    return num1+num2
}

5.2 变长参数

可以使用vararg来定义变长参数，在java中变长参数一般使用类型+"…"来规定，且必须处于函数参数列表的最后一位，例如String…
而在Kotlin中，因为具名参数存在的关系，变长参数可以处于函数参数列表的任意位置，举个🌰：

fun main(args:Array<String>) {

    sum(1,2,3,4,5, name = "tom")
}

fun sum(vararg scores:Int,name:String){
    println("name = $name")
   scores.forEach (::println)
}

当我们传递参数时，变长参数此时处于一个数组之中，那么我们可以使用展开操作符对数组进行展开。要注意此操作符只能展开数组，不能展开List,且只能用于向变长参数传递实参时使用，不能重载。
例如：

fun main(args:Array<String>) {
    val array = intArrayOf(1,2,3,4,5)
    sum(*array, name = "tom")
}

fun sum(vararg scores:Int,name:String){
    println("name = $name")
   scores.forEach (::println)
}

5.3 默认参数

在使用默认参数时，只需要在函数声明除对形参赋值即可。默认参数可以出现在参数列表的任意位置，但需要注意点的是，默认参数后边的参数都需要使用具名参数去指定，否则编译器将不能识别参数。所以一般使用默认参数的时候，最好放在函数列表的最后方。
例如：

fun main(args:Array<String>) {
    val array = intArrayOf(1,2,3,4,5)
    sum(*array)
}

fun sum(vararg scores:Int,name:String="admin"){
    println("name = $name")
   scores.forEach (::println)
}