Java程序的流程控制有顺序结构、选择（分支）结构和循环结构。对于流程控制语句，哪怕是不同的编程语言，语法和结构很多都是相通的，所以学起来比较容易。本节的主要内容如下。 
一、顺序结构
程序中的语句按顺序一条一条执行下来即为顺序结构。也可以这么理解，当一个程序既不是选择结构又不是循环结构时，默认就是顺序结构。 如下计算 a+b并输出 result就是一个顺序结构。
java
public class Hello {
public static void main(String[] args) {
int a=3;
int b=4;
int result=a+b;
System.out.println(result); // 7
}
}二、选择结构
选择结构也叫分支结构/条件语句，即根据条件来选择性地执行某段代码。
1、if/else
1.1 if 语句
1）基本语法：
ymal
if (boolean 表达式 或 boolean 变量) {
条件执行体 // 为 true 时执行
}2）eg:
java
public class Demo {
public static void main(String[] args) {
int a=1;
if(a<=1){
a+=1; // a=a+1
}
System.out.println(a); // 2
}
}1.2 if-else 语句
1）基本语法：
ymal
if (boolean 表达式 或 boolean 变量) {
条件执行体 1 // 为 true 时执行
} else {
条件执行体 2 // 为 false 时执行
}2）程序的执行流程：
3）eg:
java
public class Demo {
public static void main(String[] args) {
int a=2;
if(a<=1) {
a+=1;
}else {
a+=2;
}
System.out.println(a); // 4
}
}注：可以只有 if语句，但不能没有 if 语句直接使用 else 语句.
以上代码含义用三目表达式实现:
java
public class Demo {
public static void main(String[] args) {
int a=2;
int b =(a<=1) ? (a+=1) : (a+=2);
System.out.println(a); // 4
}
}回顾------三目表达式
表达式1 ? 表达式2 : 表达式3 若表达式1为true，则返回表达式2的值，如果表达式1为false，则返回表达式3的值。
由此可知，if-else 语句与三目表达式实现的效果相同 ；但从本质上看，if-else 是语句结构，而三元运算符是一种运算符号。三元运算符运算结束后会得到一个结果，而 if-else，不能返回什么结果，只能控制语句的执行流程。
1.3 if- else if -else 语句
1）基本语法：
ymal
if (boolean 表达式 A) {
条件执行体 1 // A为 true 时执行
} else if (boolean 表达式 B) {
条件执行体 2 // B为 true 时执行
} else {
条件执行体 3 // A、B为 false 时执行
}2）程序的执行流程：
3）eg:
java
public class Demo {
public static void main(String[] args) {
int a=2;
if(a>2) {
a+=1;
}else if(a<2) {
a+=2;
}else {
a=a+3;
}
System.out.println(a); // 5
}
}注：不能单独使用 else if（必须和 if搭配使用，同 if-else 语句中不能没有 if语句直接使用 else 语句一样），可以没有 else，至少一个 else if
2、switch/case
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
2.1 基本语法
java
switch (表达式) {
case 值 1:
执行语句 1;
break; // 注意是否要写 break
case 值 2:
执行语句 2;
break;
...
case 值 n:
执行语句 n;
break;
default:
以上值都不匹配时执行的语句; // 不用写 break
}类型说明：
1）switch里的表达式可以是byte、short、int 或 char 以及 String 类型。 2）case后面必须为字符串常量或字面量（字面量也常称为常量，Java的字面量可以是任意基本数据类型。每种字面量的表示取决于类型，eg:100、'a'、"a"）。 3）case 语句中的值的数据类型必须与变量的数据类型相同（只能是常量或者字面常量）
流程简述：
变量的值与 case 语句的值相等时，执行 case。遇到 break将终止switch 语句。 case 语句中的 break 不是必须的。 default 在以上值都不匹配时执行（不需要 break 语句）
2.2 程序的执行流程
2.3 eg:
输入某学生的成绩(成绩为100分制整数，如果输入的成绩不在0-100之间，请给出出错提示。)，经判断处理后给出学生的等级，等级分类如下：（switch语句实现） 90分以上（包括90）： A 80至90分（包括80）：B 70至80分（包括70）：C 60至70分（包括60）：D 60分以下： E
java
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("请输入学生的成绩：");
int grade = in.nextInt(); // 接收键盘输入的成绩
if (grade>=0 && grade<=100)
switch(grade/10) {
case 10:
case 9: System.out.println("等级为A");break;
case 8: System.out.println("等级为B");break;
case 7: System.out.println("等级为C");break;
case 6: System.out.println("等级为D");break;
default: System.out.println("等级为E");break;
} else
System.out.println("输入错误，成绩不合法！");
}
}注：Scanner类用于获取用户输入，使用前先导包 ：import java.util.Scanner。nextInt()用于数字输入 。除此之外，还有 nextLine()，用于字符串输入。 当然，该案例也可通过 if- else if -else 语句实现，比较简单，用户可自行尝试。
二、循环结构
顾名思义：就是可以根据循环条件重复执行某段代码。
注：定义对象、变量、获取数据库连接等操作尽量移至循环体外处理，防止循环体过于冗长。
1、3种类型
先来看看 while循环和 do-while循环，二者的执行流程对比如下。
1.1 while循环
1）基本语法
java
while (boolean 表达式) {
循环体;
迭代语句; // 自增或自减，用于对循环次数的控制
}总结：先判断后执行（先判断表达式，为 true 就执行循环体，否则跳过）
2）eg：计算1-100的累加和
java
public class Test {
public static void main(String[] args) {
int sum = 0;
int n = 1;
while (n <= 100) { // 循环条件
sum = sum + n; // 累加求和
n ++; // 迭代语句，自增
}
System.out.println(sum); // 5050
}
}1.2 do-while循环
1）基本语法
java
do {
循环体;
迭代语句; // 自增或自减，用于对循环次数的控制
} while (boolean 表达式);总结：先执行后判断 （先执行一次循环体，再判断表达式，为 true 就执行循环体，否则跳过）。do while循环至少会循环一次，而while循环可能一次循环都不做。
2）eg：同上计算1-100的累加和
java
public class Test {
public static void main(String[] args) {
int sum = 0;
int n = 1;
do {
sum = sum + n; // 累加求和
n ++; // 迭代语句，自增
} while (n <= 100); // 循环条件
System.out.println(sum); // 5050
}
}相同点： 1）while 循环 和 do-while 循环的循环体至少有 1 条语句用于对循环次数的控制，简单理解就是要有循环结束的出口（死循环除外）。 2）两者对于循环条件的判断以及自增变量的处理，都要特别注意边界条件，避免陷入死循环而使资源耗费。
1.3 for循环
1）基本语法
java
for (初始化语句; boolean 表达式; 迭代语句) {
循环体;
}注意 for()里面是 ; 而不是 ,
2）eg：计算1-100的累加和
java
public class Test {
public static void main(String[] args) {
int sum = 0;
for (int i=1; i<=100; i++) {
sum += i; // sum = sum + i
}
System.out.println(sum); // 5050
}
}pass: 变量 i 可以理解为计数器，for循环会先初始化计数器，并在每次循环前检测循环条件，在每次循环后更新计数器。
注：除了 for循环，Java还提供了另一种 for each循环用于遍历数组，等之后介绍数组时会提及。
2、循环控制
2.1 break
用于结束当前所在的整个循环。eg：
java
public class Test {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 4) {
break;
}
System.out.println(i);
}
}
}当执行到 i == 4时，break会结束当前所在的整个循环。故输出为1，2，3
2.2 continue
跳过所在的本次循环剩下语句，开始下一次循环。eg：
java
public class Test {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 4) {
continue;
}
System.out.println(i);
}
}
}当执行到 i == 4时，会跳过所在的本次循环剩下语句，开始下一次循环。故输出为1-10（除4以外）的其他9个数。
2.3 return
结束所在的方法，并返回一个值（如果方法声明了返回类型）。eg：
java
public class Test {
public static void main(String[] args) {
Test test=new Test(); // new一个对象
int result=test.sum(10,20); // 调用sum方法
System.out.println(result); // 30
}
public int sum(int a,int b) {
return a+b;
}
}使用 return结束所在的sum方法，并返回 int类型的 a+b的值。
注：如果该方法带有返回类型，return 语句就必须返回这个类型的值；更多细节会在后面介绍面向对象方法的时候提及。
3、两种循环
3.1 死循环
1）语法
java
while (true) { // while循环对应的死循环
}
do { // do-while循环对应的死循环
} while (true)
for ( ; ; ) { // for循环对应的死循环
}2）eg
java
public class Test {
public static void main(String[] args) {
int a = 1;
while (a>=1) { // a>=1恒为 true
a+=1;
}
System.out.println(a); // -2147483648
}
}如上是一个死循环，由于 Java的int类型有最大值，达到最大值后，再加1会变成负数（溢出），结果，意外退出了while循环。
pass:要尽量避免写死循环，避免犯低级错误。
3.2 嵌套循环
顾名思义，就是循环里面再套循环（套娃）。简单理解就是，重复的操作（内层循环） 需要做 n 次（外层循环）。嵌套循环非常常见，但凡不是非常简单的循环程序，一般都是嵌套循环结构。比如，算法题中使用暴力求解就是用的嵌套循环（如3层 for循环或更多层），当然，这是在不考虑最优时间复杂度或最优解的情况下才用的求解办法，因为 for循环堆嵌太多不仅会影响代码美感，而且会影响算法的执行效率。
1）两点建议：
1 将循环变量的声明放在循环外 2 将循环次数少的作为外层循环
2）eg：经典程序--打印九九乘法表
java
public class Test {
public static void main(String[] args) {
System.out.println("九九乘法表：");
for (int i = 1; i <= 9; i++) { // 外层循环
for (int j = 1; j <= i; j++) { // 内层循环
System.out.print(j + "x" + i + "=" + i*j +"\t");
}
System.out.println(); // 实现换行显示
}
}
}效果如下图：
