开发教程您现在的位置:主页 > 开发教程 >

Java中的流程控制语句

发布日期:2018-01-15 09:32

流程控制语句是编程语言中的核心之一。可以分为分支语句、循环语句和跳转语句。以下是西安Java培训整理的流程控制语句。
If 表达式
在Kotlin中全部都是表达式,也就是说全部都回来一个值。如果 if 条件不含有一个 exception ,那我们可以像我们往常那样运用它:
if(x > 0) {
    toast("x is greater than 0")
} else if(x == 0) {
    toast("x equals 0")
} else {
    toast("x is smaller than 0")
}
我们也可以把成果赋值给一个变量:
val res = if (x != null && x.size() >= days) x else null
这也说明我也不需求像 C# 那样要有一个三元操作符,因为我们可以运用 if 来简略的完结相同的功用:
val z = if (condition) x else y
所以 if 表达式总是回来一个 value 。如果一个分支回来了 Unit ,那整个表达式也将回来 Unit 。而当运用 if 做表达式时,有必要要有 else。
When 表达式
when 表达式与C#中的 switch/case 类似,但是要强大得多。when 会去试图匹配全部可能的分支直到找到满意的一项。然后它会运转右边的表达式。与C#的 switch/case 不同之处是参数可以是任何类型,而且分支也可以是一个条件。
关于默许的选项,我们可以添加一个 else 分支,它会在前面没有任何条件匹配时再实行。条件匹配成功后实行的代码也可以是代码块:
when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("I'm a block")
        print("x is neither 1 nor 2")
    }
}
因为它是一个表达式,它也可以回来一个值。我们需求考虑什么时分作为一个表达式运用,它有必要要掩盖全部分支的可能性或许完结 else 分支。不然它不会被编译成功:
val result = when (x) {
    0, 1 -> "binary"
    else -> "error"
}
如上所示,条件也可以是一系列被逗号切开的值。但是它可以有更多的匹配方法。比如,我们可以检测参数类型并进行判断:
when(view) {
    is TextView -> view.setText("I'm a TextView")
    is EditText -> toast("EditText value: ${view.getText()}")
    is ViewGroup -> toast("Number of children: ${view.getChildCount()} ")
    else -> view.visibility = View.GONE
}
再条件右边的代码中,参数会被自动转型,所以你不需求去明确地做类型变换。
它还让检测参数否在一个数组规划甚至是集结规划:
val cost = when(x) {
    in 1..10 -> "cheap"
    in 10..100 -> "regular"
    in 100..1000 -> "expensive"
    in specialValues -> "special value!"
    else -> "not rated"
}
你甚至可以从对参数做需求的简直张狂的检查脱节出来:
valres = when {
    x in 1..10 -> "cheap"
    s.contains("hello") -> "it's a welcome!"
    v is ViewGroup -> "child count: ${v.getChildCount()}"
    else -> ""
}
For 循环
for 循环可以对全部供应迭代器的变量进行迭代。等同于 C# 等言语中的 foreach,语法方法如下:
for (item in collection) {
    print(item)
}
如果你想运用索引的方法来迭代,则可以运用 ranges 方法(后面会详细介绍):
for (index in 0..viewGroup.getChildCount() - 1) {
    val view = viewGroup.getChildAt(index)
    view.visibility = View.VISIBLE
}
当我们迭代一个 array 或许 list 时,可以通过 indices 特点来更加简略的获取索引,所以上面的方法并不是必要的:
for (i in array.indices)
    print(array[i])
或许,您也可以运用 withIndex 函数,会回来索引和对应的值:
for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}
当你运用 for 来迭代 array 或许 list 时,编译器会自动将其转化为索引的方法,并不会有创建迭代器的开支。
Ranges
Range 表达式运用一个 .. 操作符,它是被定义完结了一个 RangTo 方法。Ranges 协助我们运用许多赋有创造性的方法去简化我们的代码。比如我们可以把它:
if(i >= 0 && i <= 10)
    println(i)
转化成:
if (i in 0..10)
    println(i)
Range 被定义为可以被比较的恣意类型,但是关于数字类型(IntRange, LongRange, CharRange),编译器会对其进行优化,将它变换为简略的类似于 C# 中的 for,运用索引的方法来迭代,防止额定的开支。
Ranges 默许情况下是自动添加的:
for (i in 1..4) print(i) // prints "1234"
for (x in 1.0..2.0) print("$x ") // prints "1.0 2.0 "
所以如果像以下的代码:
for (i in 10..0)
    println(i) // prints nothing
它就不会做任何作业,但你也可以运用 downTo 函数:
for(i in 10 downTo 0)
    println(i) // prints "543210"
我们也可以在 Ranges 中运用 step 来定义一个添加值:
for (i in 1..4 step 2) print(i) // prints "13"
for (i in 4 downTo 1 step 2) print(i) // prints "42"
for (i in 1.0..2.0 step 0.3) print("$i ") // prints "1.0 1.3 1.6 1.9 "
如果你想去创建一个 open range(不包括终究一项,类似数学中的开区间),则可以运用 until 函数:
for (i in 0 until 4) println(i)
这一行会打印从0到3,但是会跳过终究一个值。这也就是说 0 until 4 == 0..3 。在一个list中迭代时,运用 (i in 0 until list.size) 比 (i in 0..list.size - 1) 更加简略了解。
就如之前所说到的,运用 Ranges 确实是赋有创造性的方法。比如,一个简略的方法去从一个 ViewGroup 中得到一个 Views 列表可以这么做:
val views = (0..viewGroup.childCount - 1).map { viewGroup.getChildAt(it) }
混合运用 Ranges 和 函数操作符,可以节约许多代码,不用我们闪现的去迭代一个集结,以及明确地去创建一个我们用来添加 views 的 list,全部的作业都在一行代码中完结了。
while 和 do/while 循环
你也可以运用 while 循环,尽管它们两个都不是特别常用的。它们一般可以更简略、视觉上更简略了解的方法去处理一个问题,两个比如:
while(x > 0){
    x--
}
do{
    val y = retrieveData()
} while (y != null) // y在这儿是可见的!
while 和 do...while 和其它言语没什么差异。
回来与跳转
Kotlin 有三个流程跳转表达式:
return 从最近的函数或许匿名函数中回来。
break 停止最近的循环。
continue 跳出本次循环,实行下一次循环。
而它们都可以做为其它表达式的一部分来实行:
val s = person.name ?: return
Break 和 Continue 标签
在 kotlin 中,全部的表达式都可以添加一个标签,标签通过在结尾添加一个 @ 符号来标明,比如:*abc@*,foo@ 等都是有用的标签,然后将标签放在我们需求的表达式前面即可:
loop@ for (i in 1..100) {
    // ...
}
现在,我们可以为 break 指定我们符号的表达式:
loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (...) break@loop
    }
}
这样,break 停止的便不再是最近的循环,而是 loop@ 所指定的循环。
Return 标签
在 Kotlin 中,字面函数,部分函数,以及方针表达式中,函数都可以嵌套,而结合 lable 可以让我们从外部函数回来,更重要的是可以从 lambda 表达式中回来,看我们之前下的比如:
fun main(args: Array) {
    foo()
}
val ints = listOf(0, 1, 2, 3)fun foo() {
    ints.forEach() {
        if (it == 1) return
        println(it)
    }
}
这段代码只会输出一个 0 ,因为 return 表达式回来的是最近的闭合函数,即 foo。如果我们想从 lambda 表达式中回来,可以运用为 return 指定一个标签:
fun foo() {
    ints.forEach lit@ {
        if (it ==0) return@lit
        print(it)
    }
}
如上,会输出 123,但这儿还有一种更简练的写法:直接运用以 lambda 表达式的称谓做为标签:
fun foo() {
    ints.forEach {
        if (it == 0) return@forEach
        print(it)
    }
}
其他,我们也可以用函数表达式替代匿名函数。在函数表达式中运用 return 句子则可以从函数表达式中回来:
fun foo() {
    ints.forEach(fun(value:  Int){
        if (value == 0) return
        print(value)
    })
}
失常
全部的失常类都是 Exception 的子类,完结了 Throwable,每个失常都有一个音讯,栈踪影和可选的原因。
运用 throw 表达式,抛出失常:
throw MyException("Hi exception!")
运用 try 捕获失常:
try {
    // 一些代码
}catch (e: SomeException) {
    // 处理
}finally {
    // 可选的finally块
}
在 Kotlin 中, throw 和 try 都是表达式,这意味着它们可以被赋值给一个变量。这个在处理一些边界问题的时分确实非常有用:
val s = when(x) {
    is Int -> "Int instance"
    is String -> "String instance"
    else -> throw UnsupportedOperationException("Not valid type")
}
或许:
val s = try { x as String } catch(e: ClassCastException) { null }
try 回来值要么是 try 块的终究一个表达式,要么是 catch 块的终究一个表达式,finally 块的内容不会对表达式有任何影响。
而在 Kotlin 中,并不运用显式失常,这标明不会强逼我们在任何地方运用 try/catch 。这与Java中不太一样,比如在抛出 IOException 的方法,我们有必要运用 try-catch 来围住代码块,通过检查 exception 来处理,这并不是一个好的方法。
比如,下面是 JDK StringBuilder 类完结的一个接口
Appendable append(CharSequence csq) throws IOException;
这个签名说了什么?每次当我把一些字符串附加到 StringBuilder 中或许是 log console 等等,都需求捕获 IOExceptions 。为什么呢?因为可能涉及到 IO 操作(Writer 也完结了 Appendable)... 所以导致全部完结 Appendable 的接口都要捕获 IOException 失常。
try {
    log.append(message)
}catch (IOException e) {
    // Must be safe
}