Java基础—控制流程语句（条件语句与循环结构）

　　与任何程序设计语言一样，Java使用条件语句和循环结构确定控制流程。Java的控制流程结构与C和C++的控制流程机构一样，只有很少的例外情况。没有goto语句，但break语句可以带标签，可以利用它实现从内层循环跳出的目的（这种情况C语言采用goto语句实现）。另外，Java SE 5.0还添加了一种变形的for循环，在C或者C++中没有这类循环。它有点类似于C#中的foreach循环。

1.块作用域

　　在学习控制结构之前，需要了解块（block）的概念。

　　块（即复合语句）是指由一对花括号括起来的若干条简单的Java语句。块确定了变量的作用域。一个块可以嵌套在另一个块中。下面就是在main方法中嵌套另一个语句块的示例：

public static void main(String[]  args){
    int n;
    ...
       {
            int k;
            ...
        } //k is only defined up to here
}    

　　但是，不能在嵌套的两个块中声明同名的变量。例如，下面的代码就有错误，而无法通过编译：

public static void main(String[]  args){
    int n;
    ...
       {
            int k;
            int n;
            ...
        } //error -- cannot redefine n in inner block
}

2.条件语句

　　在Java中，条件语句的格式为：

if (condition) statement

　　这里的条件必须用括号括起来。

　　与绝大多数程序设计语言一样，Java常常希望在某个条件为真时执行多条语句。在这种情况下，应该使用块语句（block statement），格式为：

{
    statement1
    statement2
    ...
}

　　例如：

if (youSales >= target){
    performance = "Satisfactory";
    bonus = 100;
}

　　当youSales大于或等于target时，将执行括号中的所有语句。在Java中，比较常见的条件语句格式还有：

　　if (condition) statement1 else statement2

　　例如：

if (youSales >= target){
    performance = "Satisfactory";
    bonus = 100;
} else {
    performance = "Unsatisfactory";
    bonus = 0;
}

　　其中else部分是可选的，else字句与 最邻近的if构成一组。所以，在重复的交替出现 if...else...if...时，用一对括号将会使代码更加清晰。

if (youSales > 2 * target){
      performance = "How";
      bonus = 200;
} else if (youSales > 1.5 * target){
      performance = "are";
      bonus = 150;
} else if (youSales > target){
      performance = "you";
      bonus = 100;
} else{
      performance = "?";
      bonus = 0;
}    

3.循环

　　①、while循环

　　当条件为true时，while循环执行一条语句（也可以是一个语句块）。常用的格式为：

　　while (condition) statement;

　　如果开始循环条件的值就为false，则while循环体一次也不执行，例如：

while (balance < goal){
    balance += payment;
    double interest = balance + interestRate / 10;
    balance += interest;
    years++;
}
System.out.println(years + "years.");

　　从上述例子可以看得出来，只有满足 balance < goal 这个条件时，才会执行while循环体中的语句，否则，一次也不执行。

　　while循环语句首先检测的是循环条件。因此，循环体中的代码有可能不被执行。如果希望循环体至少执行一次，则应该将检测条件放在最后。使用do/while循环语句可以实现这种操作方式。

　　②、do/while 循环

　　它的语法格式为：

　　do statement while (condition);

　　这种循环语句先执行语句（通常是一个语句块），再检测循环条件；然后重复语句，再检测循环条件，以此类推。例如：

do {
    balance += payment;
    double interest = balance + interestRate / 10;
    balance += interest;
    years++;
    // print current balance
    ...
    // ask if ready to retire and input
    ...
} while ("N".equals(input));

　　只要输入的字母是 N，循环就重复执行。这是一个至少执行一次的循环示例。

　　③、for循环

　　for循环语句是支持迭代的一种通用结构，利用每次迭代之后更新的计数器或类似的变量来控制迭代次数。如下面程序所示：

for (int i = 1; i <=10; i++)
    System.out.println(i); // 将 1~10 输出到屏幕上

　　for循环的第1部分通常用于对计数器初始化；第2部分给出每次新一轮循环执行前要检测的循环条件；第3部分指示如何更新计数器。

　　与C++一样，尽管Java允许在for循环各个部分放置任何表达式，但有一条不成文的规则：for语句的3个部分应该对同一个计数器变量进行初始化、检测和更新。若不遵守这一规则，编写的循环往往晦涩难懂。

　　当for语句的第1部分中声明了一个变量之后，这个变量的作用域就为for循环的整个循环体。

for (int i = 1; i <= 10; i++){
    ...
}
// i no longer defined here

　　特别指出，如果在for循环语句内部定义了一个变量，这个变量就不能在循环体之外使用。因此，如果希望在for循环体之外使用循环计数器的最终值，就要确保这个变量在循环语句的前面且在外部声明！

int i;
for (i = 1; i <= 10; i++){
    ...
}
// i still defined here

　　另一方面，可以在各自独立的不同for循环中定义同名的变量：

for (int i = 1; i <= 10; i++){
    ...
}

...

for (int i = 11; i <= 20; i++){ // ok to defined another variable named i
    ...
}

　　for循环语句只不过是while循环的一种简化形式。例如：

for (int i = 10; i > 0; i--)
    System.out.println("Counting down ..." + i);

//可以重写为：

int i = 10;
while (i > 0){
    System.out.println("Counting down ..." + i);
    i--;
}

　　④、For each循环

　　Java SE 5.0增加了一种功能很强的循环结构，可以用来一次处理数组中的每个元素（其他类型的元素集合亦可），而不必为指定下标值而分心。这种增强的 for 循环的语句格式为：

　　for (variable : collection) statement

　　定义一个变量用于暂存集合中的每一个元素，并执行相应的语句（当然，也可以是语句块）。collection这一表达式必须是一个数组或者是一个实现了Iterable 接口的类对象（例如ArrayList）。例如：

int[] a = {2,3,4,5,6,7,8};
for (int element : a){
     System.out.println(element); // for each element in a
}

　　⑤、多重选择： switch语句

　　在处理多个选项时，使用 if/else 结构显得有些笨拙。Java有一个与C/C++完全一样的switch语句。

　　例如，如果建立一个包含4个选项的菜单系统，就应该使用下列代码：

Scanner in = new Scanner(System.in);
System.out.println("Select an option (1,2,3,4)");
int choice = in.nextInt();
switch (choice){
    case 1:
         ...
         break;
    case 2:
         ...
         break;
    case 3:
         ...
         break;
    case 4:
         ...
         break;
     default:
         // bad input
         ...
         break;
}

　　switch 语句将从与选项值想匹配的case标签处开始执行直到遇到break语句，或者执行到switch语句的结束处为止。如果没有相匹配的case标签，而有default子句，就执行这个子句。

　　注意：有可能触发多个case分支。如果case分支语句的末尾没有break语句，那么就会执行下一个case分支语句。这种情况相当危险，常常会引发错误。为此，我们在程序中从不使用switch语句。

　　在JDK 7 开始之前，case标签必须是整数或枚举常量，不能测试字符串。但JDK 7以后，我们可以针对字符串使用switch语句了。当switch语句中使用枚举常量时，不必再每个标签中指明枚举名，可以由switch的表达式值确定。例如：

Size sz = ...;
switch (sz){
     case SMALL: //no need to use Size.SMALL
          ...
          break;
     ...
}

　　⑥、中断控制流程语句

　　Java语言中增加了一条带标签的break语句，用于退出循环语句。例如：

while (years <= 100){
    balance += payment;
    double interest = balance + interestRate / 10;
    balance += interest;
    if (balance >= goal)  break;
    years++;
}

　　在循环开始时，如果years > 100，或者在循环体中balance >= goal，则退出循环语句。

　　与C++不同，Java还提供了一种带标签的break语句，用于跳出多重嵌套的循环语句。有时候，在嵌套很深的循环语句中会发生一些不可预料的事情，此时可能更加希望跳到嵌套的所有循环语句之外。通过添加一些额外的条件判断实现各层循环的检测很不方便。

　　这里有一个示例说明了break语句的工作状态。请注意，标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号。

Scanner in = new Scanner(System.in);
int n;
read_data:
while (...) { // this loop statement is tagged with the label
     ...
     for (...){
        System.out.print("Enter a number >= 0:");
        n = in.nextInt();
        if (n < 0){ // should never happen-cannot go on
           break read_data;
           // break out of read_data loop
           ...
    }
  }
// this statement is executed immediately after the labeled break
if (n < 0){
       // deal with bad situation
  } else{
       // carry out normal processing
  }
}

　　如果输入有误，通过执行带标签的break跳到带标签的语句块末尾。对于任何使用break语句的代码都需要检测循环是正常结束，还是有break跳出。

　　事实上，可以将标签应用到任何语句中，甚至可以应用到if语句或者块语句中

label:
{
    ...
    if (condition) break label; //exits block
    ...
}
// jumps here when the break statement executes

　　最后，还有一个 continue 语句。与break语句一样，它将中断正常的控制流程。continue 语句将控制转移到最内层循环的首部（俗话讲，就是终止本次循环，进入下一次循环）。例如：

Scanner in = new Scanner(System.in);
int n;
int sum;
while (){
     System.out.print("Enter a number :");
     n = in.nextInt();
     if (n < 0) continue;
     sum += n; // not executed if n < 0
}

　　如果 n < 0，则 continue 语句越过了当前循环体的剩余部分，立刻跳到循环首部，进行下一次循环。如果将 continue 用于 for 循环中，就可以跳到 for 循环的 "更新" 部分。例如：

for (count = 1; count <=100; count++){
     System.out.print("Enter a number, -1 to quit :");
     n = in.nextInt();
     if (n < 0) continue;
     sum += n; // not executed if n < 0
}

　　如果n < 0，则 continue 语句跳到 count++语句。当然，还有一种带标签的 continue 语句，将跳到与标签匹配的循环首部。