Kotlin流程控制语句

Kotlin流程控制语句

• 分支语句 if、when
• 循环语句 for、while
• 跳转语句 return、break、continue、throw

一.if表达式

在Kotlin中，if是一个表达式，即它会返回一个值.if作为代码块时，最后一行作为返回值

可以这样写表达式

fun max(x: Int, y: Int): Int {
   if (x > y) {
       return x
   } else {
       return y
   }
}

fun max2(x: Int, y: Int): Int {
   return if (x > y) {
       x
   } else {
       y
   }
}

这样写都是一样的

另一种写法

fun max3(x: Int, y: Int): Boolean {
    var flag= if (x > y) true else false
    return flag
}

这个意思就是如果 x大于y true 就选择true 否则选择false
举个例子:

fun max3(x: Int, y: Int): Int {
    var count= if (x > y) x else y
    return count
}

这样的话为true就是 x 否则就是y

注意:在Kotlin中没有java中的2>1?2:1这样的三目运算符

二.when表达式

Kotlin中的when表达式比java中的简单直接得多.如下:

fun transfer(a:Int):String{
    return when(a){
        1-> "One Time"
        2-> "Two Time"
        3-> "Three Time"
        else -> "null"
    }
}

1,2,3就代表 a的值 通过a的值来选择对应的字符串
当在when前面加return的时候需要 在最后写else 不return 就不用写else

三.for循环

Kotlin的for循环与java中的没有什么太大的区别,在我们的Java中for循环一般是:

for(int i =0;i<=4;i++){
    System.out. println(i);
}

而在Kotlin中for循环是:

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

这两种写法都是打印从数字0到数字4，效果是完全一样的
在Kotlin中for循环还有许多的写法,如:

    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")
    }

四.while循环

while循环没有啥特别的

五.break和continue

没有区别

六.return

在Kotlin中，除了表达式的值，有返回值的函数都要用return来返回值，就像刚才介绍if表达式的时候，可参考上面if表达式

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
        }
	 Log.d("lhf",i.toString)
    }
}

fun returnDemo2() {
    println(" start " + ::returnDemo2.name)
    val intArray = intArrayOf(1, 2, 3, 4, 5)
    intArray.forEach (
        fun(a: Int) {
            if (a == 3) {
                return
            }
             Log.d("lhf",i.toString)
        }
    )
}


fun main(vargs: Array<String>){
    returnDemo1()
    returnDemo2()
}

打印结果为:

returnDemo1函数在遇到3时会直接跳出这个函数
而returnDemo2函数只跳出了3，因为只跳出了匿名函数

七.标签(label)

在Kotlin中任何表达式都可以用标签来标记,标签的格式为表示符后跟@符号，例如 ：abc@、jump@。标签可以控制return、break和continue的跳转行为。
上面的returnDemo1的例子，如果想修改成跟returnDemo2一样的结果的话，就可以用标签来实现

fun returnDemo3() {
    Log.d("lhf"," start " + ::returnDemo3.name)
    val intArray = intArrayOf(1, 2, 3, 4, 5)
    intArray.forEach ara@{
        if (it == 3) {
            return@ara
        }
        Log.d("lhf",it.toString())
    }
}

这样出现的效果是

跟returnDemo2是一模一样的

使用标签时,在forEach 后加一个标签名(任意定,但要跟下面匹配) 加@，然后在return后先写@再加标签名 就可以实现标签控制跳转了 。
另外，我们也可以使用 隐式的标签更加的方便，该标签与接收的lambda的函数名相同。如下:

fun returnDemo4() {
    Log.d("lhf"," start " + ::returnDemo3.name)
    val intArray = intArrayOf(1, 2, 3, 4, 5)
    intArray.forEach {
        if (it == 3) {
            return@forEach
        }
        Log.d("lhf",it.toString())
    }
}

这样出也是可以完成同样的效果的

八.throw表达式

在Kotlin中throw是表达式，他的类型是特殊类型Nothing。该类型没有值.跟C、Java中的void的意思是一样的

fun fail(msg: String): Nothing{
    throw IllegalArgumentException(msg)
}

fun main(vargs: Array<String>){
    Log.d("lhf",) //打印class java.lang.Void (Kotlin reflection is not available)
    val x = null  //x的类型为Nothing?
    val l = listOf(null)  //l的类型为List<Nothing?>
    fail("oops")
}

九.this、super关键字

9.1this关键字

this关键字只有当前对象的引用。我们可以使用this拉引用变量或者成员函数。在类的成员中，this指向的是该类的当前对象.

class Person{
    val name = "Jake"
    val motherName = "Rose"

    fun sayMyName():Person{
        Log.d("lhf","sayMyName-----"+this.name) //引用变量
        Log.d("lhf","sayMyName-----"+this.sayMyFatherName().toString()) //引用成员函数
        return this  //返回当前Person实例
    }

    fun sayMyFatherName() {
        Log.d("lhf","sayMyFatherName-----"+"Jack")
    }
}

fun main() {
    val person = Person()
    val p = person.sayMyName()
    Log.d("lhf",((person === p).toString()))

}

控制台打印出:

在扩展函数或者带接收者的函数字面值中，this表示在左侧船体的接收者参数。如果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
            Log.d("lhf","outer----" + outer)   //outer实例
            Log.d("lhf","inner----" + inner)   //inner实例
            Log.d("lhf","pthis----" + pthis)   //最近的外层作用域，inner实例
            Log.d("lhf",this@Outer.oh)
            val fun1 = hello@ fun String.() {
                val d1 = this // 扩展函数，这里的作用域是String
                Log.d("lhf","d1----" + d1)
            }
            val fun2 = { s: String ->
                val d2 = this    //Lambda表达式的话，是最近的外层作用域，inner实例
                Log.d("lhf","d2----" + d2)
            }

            "abc".fun1()

            fun2("abc")

        }
    }
}

fun main() {
    Outer().Inner().m()
}

打印结果为:

9.2super关键字

super关键字可以持有指向父类的引用

open class Father{
    open val firstName = "Chen"
    open val lastName = "Jason"

    fun ff() {
        Log.d("lhf","FFF")
    }
}

class Son : Father {
    override var firstName = super.firstName
    override var lastName = "Jack"

    constructor(lastName: String){
        this.lastName = lastName
    }

    fun love() {
        super.ff()
        Log.d("lhf","${super.firstName} ${super.lastName} Love ${this.firstName} ${this.lastName}")
    }

}

fun main() {
    val son = Son("Jack")
    son.love()
}

打印结果为: