Java程序的流程控制有顺序结构、选择（分支）结构和循环结构。对于流程控制语句，哪怕是不同的编程语言，语法和结构很多都是相通的，所以学起来比较容易。本节的主要内容如下。

一、顺序结构

程序中的语句按顺序一条一条执行下来即为顺序结构。也可以这么理解，当一个程序既不是选择结构又不是循环结构时，默认就是顺序结构。
如下计算 a+b并输出 result就是一个顺序结构。

1
2
3
4
5
6
7
8
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）基本语法：

1
2
3
if (boolean 表达式 或 boolean 变量) {
    条件执行体      // 为 true 时执行
}

2）eg:

1
2
3
4
5
6
7
8
9
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）基本语法：

1
2
3
4
5
if (boolean 表达式 或 boolean 变量) {
    条件执行体 1 // 为 true 时执行 
} else {
    条件执行体 2 // 为 false 时执行
}

2）程序的执行流程：

3）eg:

1
2
3
4
5
6
7
8
9
10
11
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 语句.

以上代码含义用三目表达式实现:

1
2
3
4
5
6
7
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）基本语法：

1
2
3
4
5
6
7
if (boolean 表达式 A) {
    条件执行体 1 //     A为 true 时执行 
} else if (boolean 表达式 B) {
    条件执行体 2 //     B为 true 时执行
} else {
    条件执行体 3 //     A、B为 false 时执行
}

2）程序的执行流程：

3）eg:

1
2
3
4
5
6
7
8
9
10
11
12
13
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 基本语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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）基本语法

1
2
3
4
while (boolean 表达式) {
    循环体;
    迭代语句; // 自增或自减，用于对循环次数的控制
}

总结：先判断后执行（先判断表达式，为 true 就执行循环体，否则跳过）

2）eg：计算1-100的累加和

1
2
3
4
5
6
7
8
9
10
11
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）基本语法

1
2
3
4
do {
    循环体;
    迭代语句; // 自增或自减，用于对循环次数的控制
} while (boolean 表达式);

总结：先执行后判断（先执行一次循环体，再判断表达式，为 true 就执行循环体，否则跳过）。do while循环至少会循环一次，而while循环可能一次循环都不做。

2）eg：同上计算1-100的累加和

1
2
3
4
5
6
7
8
9
10
11
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）基本语法

1
2
3
for (初始化语句; boolean 表达式; 迭代语句) {
    循环体;
}

注意 for()里面是 ; 而不是 ,

2）eg：计算1-100的累加和

1
2
3
4
5
6
7
8
9
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：

1
2
3
4
5
6
7
8
9
10
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：

1
2
3
4
5
6
7
8
9
10
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：

1
2
3
4
5
6
7
8
9
10
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）语法

1
2
3
4
5
6
7
8
while (true) {  // while循环对应的死循环
}

do {    // do-while循环对应的死循环
} while (true)

for ( ; ; ) {   // for循环对应的死循环
}

2）eg

1
2
3
4
5
6
7
8
9
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：经典程序–打印九九乘法表

1
2
3
4
5
6
7
8
9
10
11
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(); // 实现换行显示
        }
    }
}

效果如下图：