控制流语句
源文件中的语句通常按照它们出现的顺序从上到下执行，但是，控制流语句通过使用决策、循环和分支来分解执行流程，使你的程序能够有条件地执行特定的代码块，本节描述Java编程语言支持的决策语句（if-then，if-then-else，switch），循环语句（for，while，do-while）以及分支语句（break，continue，return）。
if-then和if-then-else语句
if-then语句
if-then语句是所有控制流语句中最基本的语句，它告诉程序只有在特定测试评估为true时才执行某段代码，例如，Bicycle类可以允许制动器仅在自行车已经运动时降低自行车的速度，applyBrakes方法的一种可能实现如下：
void applyBrakes() {
// the "if" clause: bicycle must be moving
if (isMoving){
// the "then" clause: decrease current speed
currentSpeed--;
}
}如果此测试评估为false（意味着自行车不运动），则控制跳转到if-then语句的末尾。
此外，只要“then”子句只包含一个语句，开括号和结束括号是可选的：
void applyBrakes() {
// same as above, but without braces
if (isMoving)
currentSpeed--;
}决定何时省略括号是个人品味的问题，省略它们会使代码变得更脆弱，如果稍后将第二个语句添加到“then”子句中，则常见的错误是忘记添加新所需的花括号，编译器无法捕获这种错误，你会得到错误的结果。
if-then-else语句
if-then-else语句在“if”子句求值为false时提供辅助执行路径，如果在自行车不运动时应用制动器，你可以在applyBrakes方法中使用if-then-else语句来执行某些操作，在这种情况下，操作是简单地打印一条错误消息，指出自行车已经停止。
void applyBrakes() {
if (isMoving) {
currentSpeed--;
} else {
System.err.println("The bicycle has already stopped!");
}
}以下程序IfElseDemo根据测试分数的值分配成绩：A得分为90％或以上，B得分为80％或以上，依此类推。
class IfElseDemo {
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade = " + grade);
}
}该程序的输出是：
Grade = C你可能已经注意到testscore的值可以满足复合语句中的多个表达式：76 >= 70和76 >= 60，但是，一旦满足条件，就会执行适当的语句（grade ='C';），并且不评估其余条件。
switch语句
与if-then和if-then-else语句不同，switch语句可以有许多可能的执行路径，switch使用byte、short、char和int原始数据类型，它还适用于枚举类型（在枚举类型中讨论），String类，以及一些包含某些基本类型的特殊类：Character、Byte、Short和Integer（在Number和String中讨论）。
以下代码示例SwitchDemo声明了一个名为month的int，其值表示月份，代码使用switch语句根据month的值显示月份的名称。
public class SwitchDemo {
public static void main(String[] args) {
int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
case 4: monthString = "April";
break;
case 5: monthString = "May";
break;
case 6: monthString = "June";
break;
case 7: monthString = "July";
break;
case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}在这种情况下，August打印到标准输出。
switch语句的主体称为switch块，可以使用一个或多个case或默认标签来标记switch块中的语句，switch语句计算其表达式，然后执行匹配的case标签后面的所有语句。
你还可以使用if-then-else语句显示月份的名称：
int month = 8;
if (month == 1) {
System.out.println("January");
} else if (month == 2) {
System.out.println("February");
}
... // and so on决定是否使用if-then-else语句或switch语句是基于可读性和语句正在测试的表达式，if-then-else语句可以基于值或条件的范围来测试表达式，而switch语句仅基于单个整数、枚举值或String对象来测试表达式。
另一个兴趣点是break语句，每个break语句都会终止封闭的switch语句。控制流继续switch块后面的第一个语句，break语句是必要的，因为没有它们，switch块中的语句就会失败：匹配的case标签之后的所有语句都按顺序执行，而不管后续case标签的表达式，直到遇到break语句。程序SwitchDemoFallThrough显示落入所有switch块中的语句，该程序显示与整数月相对应的月份以及该年份中的月份：
public class SwitchDemoFallThrough {
public static void main(String[] args) {
java.util.ArrayList<String> futureMonths =
new java.util.ArrayList<String>();
int month = 8;
switch (month) {
case 1: futureMonths.add("January");
case 2: futureMonths.add("February");
case 3: futureMonths.add("March");
case 4: futureMonths.add("April");
case 5: futureMonths.add("May");
case 6: futureMonths.add("June");
case 7: futureMonths.add("July");
case 8: futureMonths.add("August");
case 9: futureMonths.add("September");
case 10: futureMonths.add("October");
case 11: futureMonths.add("November");
case 12: futureMonths.add("December");
break;
default: break;
}
if (futureMonths.isEmpty()) {
System.out.println("Invalid month number");
} else {
for (String monthName : futureMonths) {
System.out.println(monthName);
}
}
}
}这是代码的输出：
August
September
October
November
December从技术上讲，不需要最后的break，因为流从switch语句中退出，建议使用break，以便更容易修改代码并减少错误，默认部分处理其中一个case部分未明确处理的所有值。
以下代码示例SwitchDemo2显示了语句如何具有多个case标签，代码示例计算特定月份的天数：
class SwitchDemo2 {
public static void main(String[] args) {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1: case 3: case 5:
case 7: case 8: case 10:
case 12:
numDays = 31;
break;
case 4: case 6:
case 9: case 11:
numDays = 30;
break;
case 2:
if (((year % 4 == 0) &&
!(year % 100 == 0))
|| (year % 400 == 0))
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = "
+ numDays);
}
}这是代码的输出：
Number of Days = 29在switch语句中使用String
在Java SE 7及更高版本中，你可以在switch语句的表达式中使用String对象，以下代码示例StringSwitchDemo根据名为month的String的值显示月份的编号：
public class StringSwitchDemo {
public static int getMonthNumber(String month) {
int monthNumber = 0;
if (month == null) {
return monthNumber;
}
switch (month.toLowerCase()) {
case "january":
monthNumber = 1;
break;
case "february":
monthNumber = 2;
break;
case "march":
monthNumber = 3;
break;
case "april":
monthNumber = 4;
break;
case "may":
monthNumber = 5;
break;
case "june":
monthNumber = 6;
break;
case "july":
monthNumber = 7;
break;
case "august":
monthNumber = 8;
break;
case "september":
monthNumber = 9;
break;
case "october":
monthNumber = 10;
break;
case "november":
monthNumber = 11;
break;
case "december":
monthNumber = 12;
break;
default:
monthNumber = 0;
break;
}
return monthNumber;
}
public static void main(String[] args) {
String month = "August";
int returnedMonthNumber =
StringSwitchDemo.getMonthNumber(month);
if (returnedMonthNumber == 0) {
System.out.println("Invalid month");
} else {
System.out.println(returnedMonthNumber);
}
}
}此代码的输出为8。
将switch表达式中的String与每个case标签关联的表达式进行比较，就好像正在使用String.equals方法一样。为了使StringSwitchDemo示例无论何种情况都接受任何month，month将转换为小写（使用toLowerCase方法），并且与case标签关联的所有字符串均为小写。
此示例检查switch语句中的表达式是否为null，确保任何switch语句中的表达式不为null，以防止抛出NullPointerException。
while和do-while语句
while语句在特定条件为true时继续执行语句块，其语法可表示为：
while (expression) {
statement(s)
}while语句计算表达式，该表达式必须返回一个布尔值，如果表达式的计算结果为true，则while语句将执行while块中的语句，while语句继续测试表达式并执行其块，直到表达式求值为false，使用while语句打印1到10之间的值可以在以下WhileDemo程序中完成：
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}你可以使用while语句实现无限循环，如下所示：
while (true){
// your code goes here
}Java编程语言还提供了do-while语句，可以表示如下：
do {
statement(s)
} while (expression);do-while和while之间的区别在于do-while在循环的底部而不是顶部计算它的表达式，因此，do块中的语句总是至少执行一次，如下面的DoWhileDemo程序所示：
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " + count);
count++;
} while (count < 11);
}
}
for语句
for语句提供了一种迭代一系列值的简洁方法，程序员经常将其称为“for循环”，因为它反复循环直到满足特定条件，for语句的一般形式可表示如下：
for (initialization; termination; increment) {
statement(s)
}使用此版本的for语句时，请记住：
-
initialization表达式初始化循环，循环开始时，它执行一次。 - 当
termination表达式的计算结果为false时，循环终止。 - 每次迭代循环后都会调用
increment表达式，这个表达式增加或减少一个值是完全可以接受的。
以下程序ForDemo使用for语句的一般形式将数字1到10打印到标准输出：
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
}
}该程序的输出是：
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10注意代码如何在初始化表达式中声明变量，此变量的范围从其声明扩展到由for语句控制的块的末尾，因此它也可以用在终止和增量表达式中。如果在循环外部不需要控制for语句的变量，则最好在初始化表达式中声明该变量。名称i，j和k通常用于控制循环，在初始化表达式中声明它们会限制它们的生命周期并减少错误。
for循环的三个表达式是可选的，可以创建一个无限循环，如下所示：
// infinite loop
for ( ; ; ) {
// your code goes here
}for语句还有另一种用于迭代集合和数组的形式，此形式有时也称为增强的for语句，可用于使循环更紧凑，更易于阅读，要演示，请考虑以下数组，其中包含数字1到10：：
int[] numbers = {1,2,3,4,5,6,7,8,9,10};以下程序EnhancedForDemo使用增强型for循环遍历数组：
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers =
{1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}在此示例中，变量item保存数字数组中的当前值，该程序的输出与之前相同：
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10我们建议尽可能使用for语句的这种形式而不是一般形式。
分支语句
break语句
break语句有两种形式：标记和未标记，你在前面的switch语句讨论中看到了未标记的形式，你还可以使用未标记的break来终止for、while或do-while循环，如以下BreakDemo程序所示：
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
}该程序在数组中搜索数字12，break语句在找到该值时终止for循环，然后，控制流转移到for循环后的语句，该程序的输出是：
Found 12 at index 4未标记的break语句终止最内层的switch、for、while或do-while语句，但带标签的break终止外部语句。以下程序BreakWithLabelDemo与前一个程序类似，但使用嵌套for循环来搜索二维数组中的值，找到该值后，带标签的break将终止外部for循环（标记为“search”）：
class BreakWithLabelDemo {
public static void main(String[] args) {
int[][] arrayOfInts = {
{ 32, 87, 3, 589 },
{ 12, 1076, 2000, 8 },
{ 622, 127, 77, 955 }
};
int searchfor = 12;
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at " + i + ", " + j);
} else {
System.out.println(searchfor + " not in the array");
}
}
}这是该程序的输出。
Found 12 at 1, 0break语句终止带标签的语句，它不会将控制流转移到标签上，控制流在标记（终止）语句之后立即转移到语句。
continue语句
continue语句跳过for、while或do-while循环的当前迭代，未标记的形式跳到最内层循环体的末尾，并计算控制循环的布尔表达式。以下程序ContinueDemo逐步执行字符串，计算字母“p”的出现次数，如果当前字符不是p，则continue语句将跳过循环的其余部分并继续执行下一个字符，如果是“p”，程序会增加字母数。
class ContinueDemo {
public static void main(String[] args) {
String searchMe = "peter piper picked a " + "peck of pickled peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {
// interested only in p's
if (searchMe.charAt(i) != 'p')
continue;
// process p's
numPs++;
}
System.out.println("Found " + numPs + " p's in the string.");
}
}这是该程序的输出：
Found 9 p's in the string.要更清楚地看到此效果，请尝试删除continue语句并重新编译，当你再次运行程序时，计数将是错误的，说它找到35个p而不是9个。
标记的continue语句跳过标记有给定标签的外循环的当前迭代，以下示例程序ContinueWithLabelDemo使用嵌套循环来搜索另一个字符串中的子字符串，需要两个嵌套循环：一个遍历子字符串，一个迭代搜索的字符串，以下程序ContinueWithLabelDemo使用标记形式的continue来跳过外部循环中的迭代。
class ContinueWithLabelDemo {
public static void main(String[] args) {
String searchMe = "Look for a substring in me";
String substring = "sub";
boolean foundIt = false;
int max = searchMe.length() -
substring.length();
test:
for (int i = 0; i <= max; i++) {
int n = substring.length();
int j = i;
int k = 0;
while (n-- != 0) {
if (searchMe.charAt(j++) != substring.charAt(k++)) {
continue test;
}
}
foundIt = true;
break test;
}
System.out.println(foundIt ? "Found it" : "Didn't find it");
}
}这是该程序的输出。
Found itreturn语句
最后一个分支语句是return语句，return语句从当前方法退出，控制流返回到调用方法的位置，return语句有两种形式：一种是返回值，另一种是不返回值，要返回值，只需将值（或计算值的表达式）放在return关键字之后。
return ++count;返回值的数据类型必须与方法声明的返回值的类型匹配，当方法声明为void时，请使用不返回值的return形式。
return;类和对象课程将涵盖你需要了解的有关编写方法的所有内容。
控制流程语句总结
if-then语句是所有控制流语句中最基本的语句，它告诉程序只有在特定测试评估为true时才执行某段代码。if-then-else语句在“if”子句求值为false时提供辅助执行路径，与if-then和if-then-else不同，switch语句允许任意数量的可能执行路径。while和do-while语句在特定条件为true时不断执行语句块，do-while和while之间的区别在于do-while在循环的底部而不是顶部计算它的表达式，因此，do块中的语句总是至少执行一次。for语句提供了一种迭代一系列值的简洁方法，它有两种形式，其中一种用于循环集合和数组。
