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()
}
打印结果为: