本文详细介绍了Java中的流程控制结构，包括顺序结构（按顺序执行）、分支结构（if,if-else,if...elseif...else）和循环结构（for,while,do...while）。此外，还讨论了switch语句、无限循环、break和continue语句的用法，以及它们在控制程序执行路径中的作用。
流程控制：控制流程（也称为流程控制）是计算机运算领域的用语，意指在程序运行时，个别的指令（或是陈述、子程序）运行或求值的顺序。
Java 中的流程控制分为三种：
顺序结构
分支结构
循环结构
顺序结构
Java中的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。指令和指令之间是按照从上向下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
分支结构
分支结构是根据指定变量或表达式的结果，决定后续运行的程序，最常用的是if-else指令，可以根据指定条件是否成立，决定后续的程序。也可以组合多个if-else指令，进行较复杂的条件判断。
Java if（if-then）语句
在Java中，if-then语句的语法为：
if (expression) {
// 语句
}这是一个布尔表达式(expression)。布尔表达式返回 true 或 false。
如果将表达式计算为true，则将if执行（大括号内的语句）主体内部的语句
如果表达式的计算结果为false，则if主体内的语句将被跳过
Java if..else（if-then-else）语句
如果if语句测试表达式的计算结果为true，则该语句执行代码的特定部分。但是，如果测试表达式的计算结果为false，则它不会执行任何操作。在这种情况下，可以使用可选 else 代码块。如果测试表达式的计算结果为false，则执行块体内的else语句。
if-then-else语句的语法为：
if (expression) {
// 代码
}
else {
// 其他代码
}
在这里，如果测试表达式为true，我们的程序将执行一个任务（if块内的任务），如果测试表达式为false，则另一项任务（else代码块内的任务）。Java if..else if语句
在Java中，我们有一个if ... else ... if 阶梯语句，可用于在多个其他代码块之间执行其中一个代码块。
if (expression1) {
// 代码
}
else if(expression2) {
// 代码
}
else if (expression3) {
// 代码
}
.
.
else {
// 代码
}
在这里，if语句从上到下执行。一旦测试表达式为true，就执行该if语句主体内的代码。然后，程序的控制跳到if-else-if阶梯语句外面。
如果所有测试表达式均为false，则执行else主体内的代码。示例：
class DemoA {
public static void main(String[] args) {
int number = 0;
//检查数字是否大于0
if (number > 0) {
System.out.println("这个数字是正数。");
}
//检查数字是否小于0
else if (number < 0) {
System.out.println("该数字为负数。");
}
else {
System.out.println("数字是0。");
}
}
}
输出：
数字是0。Java 嵌套 if..else语句
在Java中，也可以在if..else语句内if..else语句。这称为嵌套if...else语句。
//查找3个数字中，最大的一个数字
class DemoB {
public static void main(String[] args) {
//声明双精度类型变量
Double n1 = -1.0, n2 = 4.5, n3 = -5.3, largestNumber;
//检查n1是否大于或等于n2
if (n1 >= n2) {
//if ... else语句在if块内
// 检查n1是否大于或等于n3
if (n1 >= n3) {
largestNumber = n1;
}
else {
largestNumber = n3;
}
} else {
//else块中的if...else语句
//检查n2是否大于或等于n3
if (n2 >= n3) {
largestNumber = n2;
} else {
largestNumber = n3;
}
}
System.out.println("最大的数字是 " + largestNumber);
}
}
输出：
最大的数字是 4.5switch语句
在Java中，我们使用了if..else..if阶梯在多个块之间执行一个代码块。但是，if ... else ... if梯子的语法太长。因此，我们可以使用switch语句代替long if ... else ... if梯子。switch语句的使用使我们的代码更具可读性。
switch语句的语法为：
switch (variable/expression) {
case value1:
// case1 语句
break;
case value2:
// case2 语句
break;
.. .. ...
.. .. ...
default:
// default 语句
}
switch语句评估expression或variable（表达式或变量），并将其与每个case标签的值（可以是表达式）进行比较。
现在，如果值与某个case标签匹配，那么将执行匹配case标签的所有语句。
例如，如果 variable/expression 等于value2。在这种情况下，case将执行该匹配的所有语句（case2的语句）。
注意:在每种情况下都使用break语句。break语句用于终止该语句的执行switch。这很重要，因为如果不使用break语句，则case之后的所有语句将按顺序执行，直到switch语句结束。示例:使用switch语句制作计算器
下面的程序从用户那里接受三个输入：一个运算符和2个数字。根据用户提供的运算符，对这些数字进行计算。然后结果显示在屏幕上。
import java.util.Scanner;
class Democ {
public static void main(String[] args) {
char operator;
Double number1, number2, result;
//创建一个Scanner类的对象
Scanner scanner = new Scanner(System.in);
System.out.print("输入运算符 (选项： +, -, * 或 /): ");
//要求用户输入运算符
operator = scanner.next().charAt(0);
System.out.print("分别输入数字1和数字2: ");
//要求用户输入数字
number1 = scanner.nextDouble();
number2 = scanner.nextDouble();
switch (operator) {
//两个数字相加
case '+':
result = number1 + number2;
System.out.print(number1 + "+" + number2 + " = " + result);
break;
//两个数字相减
case '-':
result = number1 - number2;
System.out.print(number1 + "-" + number2 + " = " + result);
break;
//两个数字相乘
case '*':
result = number1 * number2;
System.out.print(number1 + "*" + number2 + " = " + result);
break;
//两个数字相除
case '/':
result = number1 / number2;
System.out.print(number1 + "/" + number2 + " = " + result);
break;
default:
System.out.println("Invalid operator!无效运算符！");
break;
}
}
}
输出：
输入运算符 (选项： +, -, * 或 /): *
分别输入数字1和数字2: 1.4-5.3
1.4*-5.3 = -7.419999999999999多重if | Switch-case | |
相同点 | 都是用来处理多分支条件的结构 | |
不同点 | 多重if选择结构的限制，特别适合某个变量处于某个连续区间时的情况。 | switch语句只能处理等值条件判断的情况，而且条件只能是整型变量或字符型变量。 |
循环结构
循环结构是指一段在程序中只出现一次，但可能会连续运行多次的代码。
Java for循环
Java 中for循环的语法为：
for (initialization; testExpression; update)
{
// 循环体内的代码
}for循环工作流程
初始化（initialization）表达式只执行一次。
然后，评估测试表达式（testExpression）。在这里，测试表达式（testExpression）是一个布尔表达式。
如果测试表达式（testExpression）的计算结果为true，则执行for循环体内的代码。
然后执行更新表达式（update）。
再次，评估测试表达式（initialization）。
如果测试表达式为true，则执行for循环体内的代码，并继续执行更新表达式（update）。
这个过程一直进行到测试表达式（testExpression）被评估为false时为止。
如果测试表达式（testExpression）的计算结果为false，则for循环终止。
for (int i = 1; i <= 10; ++i) {
System.out.println("Line " + i);
}
初始化表达式：int i = 1
条件表达式：i <= 10
控制表达式：++ i无限循环
在使用循环时，我们应始终小心。这是因为如果我们错误地将测试表达式设置为从不为false时，则for循环将永远运行。
//无限循环
class DemoD {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 10; --i) {
System.out.println("Hello");
}
}
}
在这里，条件表达式（i <= 10）永远不会出现false，并且hello会无数次打印（至少在理论上是这样）。Java for-each循环(遍历循环)
for-each循环的语法为：
for(data_type item : collections) {
...
}
• collection -您需要遍历的集合或数组。
• item -集合中的单个项目。在Java中，在处理数组和集合时，我们可以使用增强形式的for循环。也称为for-each循环。这是因为循环会遍历数组或集合的每个元素。可用于Java数组和Java集合（称为遍历循环）。
//示例：
for (int a : array) {
System.out.println(a);
}for循环和for-each循环之间的区别
for循环和for-each循环的输出结果相同，但for-each循环更易于编写，并使我们的代码更具可读性。这就是它被称为增强for循环的原因。因此，建议尽可能在标准for循环上使用增强的for循环。
for-each 循环工作流程
对于每个迭代，执行for-each循环，这是for-each循环在Java中的工作方式。
迭代 - 遍历给定集合或数组（collections）中的每个项目，
存储 - 变量（item）中的每个项目
重复执行循环内的主体语句。
示例：
//计算整数数组的所有元素的总和。
class DemoE {
public static void main(String[] args) {
int[] numbers = {3, 4, 5, -5, 0, 12};
int sum = 0;
for (int number: numbers) {
sum += number;
}
System.out.println("Sum = " + sum);
}
}
输出：
Sum = 19
在上面的程序中，for-each循环的执行如下：
迭代值
1 number = 3 时， sum = 0 + 3 = 3
2 number = 4 时，sum = 3 + 4 = 7
3 number = 5 时，sum = 7 + 5 = 12
4 number = -5 时，sum = 12 + (-5) = 7
5 number = 0 时，sum = 7 + 0 = 7
6 number = 12 时，sum = 7 + 12 = 19Java while循环
Java 中 while循环的语法为：
while (testExpression) {
// while循环体中的代码
}while循环工作流程
在以上语法中，括号内的测试表达式(testExpression)为布尔表达式。
如果测试表达式(testExpression)的计算结果为true，while循环内的语句将被执行。
然后，再次评估测试表达式(testExpression)。这个过程一直进行到测试表达式被评估为false为止。
如果测试表达式的计算结果为false，则while循环被终止。
//打印行10次
class DemoF {
public static void main(String[] args) {
int i = 1;
while (i <= 10) {
System.out.println("Line " + i);
++i;
}
}
}do... while循环
do...while循环类似于while循环，但是有个关键区别，在于在检查测试表达式之前，会执行循环主体一次。
do...while循环的语法为:
do {
// do...while循环体内的代码
} while (testExpression);do... while 循环工作流程
do...while循环主体执行一次（在检查测试表达式之前）。只有这样，测试表达式才会被检查。
如果测试表达式被计算为true，则执行循环体中的代码，并再次计算测试表达式。这个过程一直进行下去，直到测试表达式被计算为false为止。
当测试表达式为时false，do..while循环终止。
//计算用户输入的数字总和，直到用户输入0。
import java.util.Scanner;
class DemoG {
public static void main(String[] args) {
Double number, sum = 0.0;
//创建一个Scanner类的对象
Scanner input = new Scanner(System.in);
do {
//接受用户的输入
System.out.print("输入一个数字: ");
number = input.nextDouble();
sum += number;
} while (number != 0.0);
System.out.println("Sum = " + sum);
}
}
输出：
输入一个数字: 2.5
输入一个数字: 23.3
输入一个数字: -4.2
输入一个数字: 3.4
输入一个数字: 0
Sum = 25.0无限循环
在使用循环时，我们应始终小心。 这是因为如果我们错误地设置了测试表达式，使其永远不会为false，则while和do ... while循环将永远运行。这就是所谓的无限while和do...while循环。
//无限while循环
while (true) {
//while循环主体
}
//无限do...while循环
do {
// do...while循环体内的代码
} while (true);break语句
Java中的break语句立即终止循环，程序的控制权移至循环后的下一条语句。break语句它几乎总是与决策语句（Java if ... else语句）一起使用。
//break语句的语法
break;
注意：对于嵌套循环，break语句终止最里面的循环。class DemoH {
public static void main(String[] args) {
// for 循环
for (int i = 1; i <= 10; ++i) {
//如果i的值为5，则循环终止
if (i == 5) {
break;
}
System.out.println(i);
}
}
}
输出：
1
2
3
4带标记的break语句
Java中还有另一种break语句形式，称为带标签的break。我们可以使用标记的break语句终止最外面的循环。
class DemoI {
public static void main(String[] args) {
//for循环标记为first
first:
for( int i = 1; i < 5; i++) {
//for循环标记为second
second:
for(int j = 1; j < 3; j ++ ) {
System.out.println("i = " + i + "; j = " +j);
//break语句终止第一个for循环
if ( i == 2)
break first;
}
}
}
}
输出：
i = 1; j = 1
i = 1; j = 2
i = 2; j = 1
在上面的代码中，break语句用于终止标记为first的循环。
如果我们更改break first为 break second，程序的行为将不同。在这种情况下，标记为second的for循环将被终止。
class DemoJ {
public static void main(String[] args) {
//for循环标记为first
first:
for( int i = 1; i < 5; i++) {
//for循环标记为second
second:
for(int j = 1; j < 3; j ++ ) {
System.out.println("i = " + i + "; j = " +j);
//break语句终止标记为second的循环
if ( i == 2)
break second;
}
}
}
}
输出：
i = 1; j = 1
i = 1; j = 2
i = 2; j = 1
i = 3; j = 1
i = 3; j = 2
i = 4; j = 1
i = 4; j = 2continue语句
Java中的continue语句跳过循环的当前迭代（for，while，do…while等），程序的控制权移到循环的末尾。
//它的语法是：
continue;
注意：对于嵌套循环，则continue将跳过最内层循环的当前迭代。
注意：通常不建议使用带标签的continue，因为这会使代码难以理解。如果您处于必须使用标记为continue的情况下，请重构代码并尝试以不同的方式解决它，以使其更具可读性。class DemoK {
public static void main(String[] args) {
Double number, sum = 0.0;
//创建Scanner对象
Scanner input = new Scanner(System.in);
for (int i = 1; i < 6; ++i) {
System.out.print("输入一个数字: ");
//接受double类型的数据输入
number = input.nextDouble();
//如果number为负数，则跳过迭代
if (number <= 0.0) {
continue;
}
sum += number;
}
System.out.println("Sum = " + sum);
}
}
输出：
输入一个数字: 2.2
输入一个数字: 5.6
输入一个数字: 0
输入一个数字: -2.4
输入一个数字: -3
Sum = 7.8
这意味着当用户输入负数时，将跳过循环的当前迭代。下一个迭代就开始了。带标签的continue语句
Java中还有另一种形式的continue语句，称为标记contine。
class DemoL {
public static void main(String[] args) {
//外部for循环标记为label
first:
for (int i = 1; i < 6; ++i) {
for (int j = 1; j < 5; ++j) {
if (i == 3 || j == 2)
//跳过标签的迭代(外部for循环)
continue first;
System.out.println("i = " + i + "; j = " + j);
}
}
}
}
输出：
i = 1; j = 1
i = 2; j = 1
i = 4; j = 1
i = 5; j = 1
在上面的代码中，使用带标签的continue语句跳过标记为first的循环的当前迭代。因此，如果i的值为3或j的值为2，则跳过外部for循环的迭代。break与continue的关系
break：作用于完全结束一个循环，跳出循环体执行循环后面的语句。
continue：作用是跳过本次循环体中余下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为仅结束本次循环。
break和continue之间的区别：
break只能在循环体内和switch语句体内使用。break语句可以使流程跳出switch语句体，也可以用break语句在循环结构中终止本层循环体，从而提前结束本层循环。
continue 只能在循环语句中使用。continue语句的作用是跳过本次循环体中余下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为仅结束本次循环。continue语句并没有使整个循环终止。
扫一扫
871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
