【西行 - 大圣闹天宫】 Java 流程控制-阿里云开发者社区

1、顺序结构

任何编程语言中，最常见的程序结构就是顺序结构。

顺序结构指程序从上到下逐行地执行，中间没有任何判断和跳转。

在 main 方法中多行代码之间没有任何流程控制，则程序总是从上向下一次执行，排在前面的代码先执行，排在后面的代码后执行。

2、分支结构

Java 提供了两种常见的分支控制结构：

switch

if 语句使用布尔表达式或布尔值作为分支条件进行分支控制；而 switch 语句则用于对多个整型值（Java 7 支持String类型）进行匹配，从而实现分支控制。

2.1 if 条件语句

if 语句有下列三种形式。

第一种：

if (条件表达式){
    // 逻辑代码
}

第二种：

if (条件表达式){
    // 逻辑代码
}else {
    // 逻辑代码
}

第三种：

if (条件表达式1){
    // 逻辑代码
}else if (条件表达式2){
    // 逻辑代码
}else if (条件表达式3){
    // 逻辑代码
}
...省略多个 else if 语句
else {
    // 逻辑代码
}

三种类型类型中，条件表达式的返回值只能是 true 或者 false。

在上面的条件语句中，if (表达式) 、else if (表达式) 和 else 后花括号括起来的多行代码被称为代码块，一个代码块通常被当成一个成体来执行（除非运行过程中遇到 return、break、continue 等关键字，或者遇到了异常），因此这个代码块也被称为条件执行体。例如如下代码。

public class BranchTest {
    public static void main(String[] args) {
        int age = 18;
        if (age == 18){
            // 只有当 age 等于 18 时下面的两个输出语句才会执行
            System.out.println("噢噢噢！原来 J3 才 18 岁。");
            System.out.println("不愧是靓仔");
        }
        System.out.println("一个毫无意义的输出，就像 J3 还认为自己 18 岁。");
    }
}

如果 if（表达式）、else if（表达式）和 else 后的代码只有一行语句是，则可以省略花括号，因为单行语句本身就是一个整体，无须用括号来把它们定义成一个整体。例如下面代码完全可以执行。

public class BranchTest {
    public static void main(String[] args) {
        int age = 17;
        if (age > 18)
            System.out.println("J3 老是拿年龄做文章，都不敢正视自己的年纪！！！");
        else
            System.out.println("嘿嘿！我要让上面的语句不能输出，敢质疑我，哼！");
    }
}

但，通常我们是不建议这样做的，即时条件执行体只有一条语句，也要保留花括号，因为可读性较好，而且这会减少错误发生的可能。

例如下面代码和想象的结果可能有不同。

public class BranchTest {
    public static void main(String[] args) {
        int age = 19;
        if (age > 18)
            System.out.println("J3 老是那年龄做文章，都不敢正视自己的年纪！！！");
        else
            System.out.println("嘿嘿！我要让上面的语句不能输出，敢质疑我，哼！");
            // 这个输出永远会执行
            System.out.println("J3 永远是 18");
    }
}

System.out.println("J3 永远是 18") 这个语句永远会执行的原因就是它不是 else 后的条件执行体。

如果，if 后面有多条语句作为条件执行体，若省略了这个条件执行体的花括号，则会引起编译错误。例如下面代码。

public class BranchTest {
    public static void main(String[] args) {
        int age = 19;
        if (age > 18)
            System.out.println("J3 老是那年龄做文章，都不敢正视自己的年纪！！！");
            System.out.println("这个输出写在这，是会报错的在没有花括号的时候！！！！！");
        else
            System.out.println("嘿嘿！我要让上面的语句不能输出，敢质疑我，哼！");
            // 这个输出永远会执行
            System.out.println("J3 永远是 18");
    }
}

2.2 switch分支语句

switch 语句由一个控制表达式和多个 case 标签组成，和 if 语句不同的是，switch 语句后面的控制表达式的数据类型只能是 byte、short、char、int 四个整数类型和枚举类型，不能是 boolean 类型。

Java 7 改进了 switch 分支语句，Java 7 允许 switch 语句中的控制表达式为 java.lang.String 类型。

switch 语句往往需要在 case 标签后紧跟着一个代码块，case 标签作为这个代码块的标识。语法格式如下。

public class BranchTest {
    public static void main(String[] args) {
        switch (表达式){
            case 情况1:{
                // 逻辑1
                break;
            }
            case 情况2:{
                // 逻辑2
                break;
            }
            ...
            default:{// 都不满足，则默认执行这个
                // 默认逻辑
            }
        }
    }
}

这种分支语句的执行先是对表达式求值，然后依次匹配情况1、情况2、…等值，遇到匹配的值及执行对应的执行体；如果所有 case 标签后的值都不与表达式的值相等，则执行 default 标签后的代码块。

和 if 语句不同的是，switch 语句中各个 case 标签后代码块的开始点和结束点非常清晰，因此完全可以省略 case 后面的花括号。

与 if 语句中的 else 类似，当 switch 表达式中的值没有任何一种情况匹配时，就会执行 default 后面的代码块。

switch 使用案例如下。

public class BranchTest {
    public static void main(String[] args) {
        char name = 'J';
        switch (name){
            case 'A':{
                System.out.println("name 等于 A");
                break;
            }
            case 'B':{
                System.out.println("name 等于 B");
                break;
            }
            case 'J':{
                System.out.println("name 等于 J");
                break;
            }
            default:{
                System.out.println("name 啥也不是！");
            }
        }
    }
}

运行结果输出了 “name 等于 J” 符合我们的预期。

看代码我们发现，每个 case 标签后面都有一条 break；语句，这个 break；语句还是挺重要的，如果把上面代码的 break；都去掉那么结果会是如下情况。

name 等于 J
name 啥也不是！

看起来有点奇怪，但这就是由 switch 语句的运行流程决定的。

switch 语句会先求出表达式的值，然后和 case 标签后的值进行比较，一旦遇到相等的值，就开始执行 cases 标签后面的代码，并不在判断后面 case、default 标签的条件是否匹配，除非是遇到 break；才会结束。

Java 7 增强了 switch 语句的功能，允许 switch 语句的控制表达式是 java.lang.String 类型的变量或者表达式（只允许了 java.lang.String 其他类型字符串不行）。例如如下代码。

public class BranchTest {
    public static void main(String[] args) {
        String blogType = "CSDN";
        switch (blogType){
            case "CSDN":{
                System.out.println("J3，CSDN老牌用户，新人作者！");
                break;
            }
            case "juejin":{
                System.out.println("J3，掘金新用户，新人作者");
                break;
            }
            case "zhihu":{
                System.out.println("J3，知乎新用户，新人作者");
                break;
            }
            default:{
                System.out.println("J3，啥也不是！");
            }
        }
    }
}

在使用 switch 时，有两个地方值得注意：

switch 表达式类型只能是 byte、short、char、int、String。

如果 case 标签后的代码省略了 break；则会一直往下执行直到碰到 break；。

3、循环结构

在循环语句中，满足循环条件的情况下，可以反复执行一段代码，重复执行的代码称为循环体。

循环结构需要注意的是，循环条件。当循环条件永远为 true 时会造成死循环。

3.1 while 循环语句

while 循环的语法格式如下：

while (表达式或布尔值) {
    // 循环体代码
}

在执行 while 循环体之前，先对表达式求值，如果条件为 true，则运行循环体部分。

下面演示一个简单的 while 循环。

public class CycleTest {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while (i <= 10) {
            // 循环，求 1 到 10 的和。
            sum = sum + i;
            i = i + 1;
        }
        System.out.println("1 到 10 的累加和：" + sum);
    }
}

值得注意的是 i <= 10 这个表达式的结果要在某个时刻变为 false ，不然程序会进行死循环，造成程序永远无法结束。

3.2 do while 循环语句

do while 循环与 while 循环的区别在于：while 循环是先判断循环条件，如果条件为真则执行循环体；而 do while 循环则先执行循环体，然后才判断循环条件，如果循环条件为真，则执行下一次循环，否则终止循环。

do while 语法格式如下。

do {
    循环体
}while (表达式);

注意，while 的后面是要跟一个分号，表明循环结束。

下面看看简单用法。

public class CycleTest {
    public static void main(String[] args) {
        int age = 16;
        do {
            System.out.println("时间，一年年的过去，转眼我 J3 已经：" + age + "岁了。");
            age = age + 1;
        } while (age < 25);
        System.out.println("转眼我都这么大了~");
    }
}

由程序我们可以发现，do while 循环不管表达式条件真假，都会执行一遍循环体。

3.3 for 循环

for 循环是一个更加简洁的循环语句，大部分情况下，for 循环可以替代 while 循环、do while 循环。

for 循环的基本语法格式如下。

for (初始化值; 循环条件 ; 迭代语句) {
    循环体
}

程序执行 for 循环时，先执行循环的初始化值，初始化值语句只在循环开始前执行一次。

每次执行循环体之前，先判断循环条件的真假，true 执行循环体，执行循环体完成之后再执行迭代语句。

因为是先判断循环条件真假，在执行循环体，所以循环条件总要比循环体多执行一遍。

简单使用案例如下。

public class CycleTest {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum = sum + i;
            System.out.println("我被执行了第 " + i + " 次。");
        }
        System.out.println("1 到 10 的累加和：" + sum);
    }
}

当然，对于初始化语句是允许指定多个初始语句，循环条件也是可以包含逻辑运算表达式。程序如下。

public class CycleTest {
    public static void main(String[] args) {
        for (int i = 0, b = 2, c = 3; i <= 7 && b < 8 && c < 9; i++) {
            System.out.println("我执行了~~~~~~~");
        }
    }
}

上面代码中初始化变量有三个，但只能有一个声明语句，因此如果需要在初始化表达式中声明多个变量，那么这些变量应该具有相同的数据类型。

在 for 循环括号中只有两个分号是必须的，初始化语句、循环条件、迭代语句部分都是可以省略的，如果省略了循环条件，则这个循环条件模式 true ，将会产生一个死循环。例如下面程序。

public class CycleTest {
    public static void main(String[] args) {
        for (; ; ) {
            System.out.println("我将要进行死循环输出了~~~");
        }
    }
}

上面代码将进行死循环，一直输出 我将要进行死循环输出了~~~ 字符串。

使用 for 循环还是以写成如下形式。

public class CycleTest {
    public static void main(String[] args) {
        // 初始语句
        int i = 1;
        for (; i <= 10 ; ) {
            System.out.println("我是变种 for 循环！");
            // 迭代语句
            i = i +2;
        }
    }
}

这种写法与 while 的形式很类似，并且这种写法的初始值 i 即时在 for 循环体外也是可以访问的，而初始化语句写在括号里面的话，则只能在循环体中使用（变量作用范围，后面介绍）。

3.4 嵌套循环

如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环了，嵌套循环既可以是 for 循环嵌套 while 循环，也可以是 while 循环嵌套 do while 循环…既各种类型的循环都可以作为外层循环，各种类型的循环也可以作为内层循环。

当外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n * m 次。

嵌套循环执行流程如下图。

从流程图中我们可以看出，嵌套循环就是把内层循环当成外层循环的循环体。

当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一次循环，下面看个简单案例。

public class NestedTest {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print( j + " * " + i + " = " + i * j + " ");
            }
            System.out.println("");
        }
    }
}

程序执行结果是一个九九乘法表，通过前面知识积累，相信理解起来不费劲。

实际上，嵌套循环不仅可以嵌套两层，只要你愿意，多少层都是可以的。但不管如何嵌套循环，我们都可以吧内层循环当成外层循环体来对待，区别只是这个循环体包含了需要反复执行的代码。

4、控制循环结构

Java 语言没有提供 goto 语句来控制程序的跳转，这种做法提高了流程控制的可读性，但降低了程程控制的灵活性。

为了弥补这种不足， Java 提供了 continue 和 break 来控制循环结构。除此之外，return 可以结束整个方法，当然也就是结束一次循环了。

4.1 break 结束循环

循环的时候我们不一定要等到循环条件为 false 的时候才退出循环，使用 break 就可以强行终止循环。

在循环中，一旦循环体中遇到 break ，系统将完全结束该循环，开始执行循环之后的代码。例如下面程序。

public class NestedTest {
    public static void main(String[] args) {
        for (int i = 1; i <= 10000; i++) {
            System.out.println("我在循环 一万次！");
            if (i == 10){
                System.out.println("让你执行 1 万次，疯了，不行，我要结束你！");
                break;
            }
        }
        System.out.println("结束了");
    }
}

break 语句不仅可以结束其所在的循环，还可以直接结束外层循环。此时需要在 break 后紧跟一个标签，这个标签用于表示一个外层循环。

Java 中的标签就是一个紧跟着英文冒号（:）的标识符。与其他语言不同的是，Java 中的标签只有放在循环语句之前才有作用。例如下面代码。

public class NestedTest {
    public static void main(String[] args) {
        // 外层循环，outo 作为标识符
        outo:
        for (int i = 1; i <= 100; i++) {
            for (int j = 1; j <= 100; j++) {
                System.out.println("我又在循环 1 万次！");
                if ( (i * j) > 10){
                    System.out.println("给你脸了，又来循环 1 万次，给我全部结束，不要执行了！");
                    // 跳出 outo 标签所在标识的循环
                    break outo;
                }
            }
        }
        System.out.println("我结束了！");
    }
}

程序从外层循环进入内层循环后，当 i * j > 10 后，程序遇到一个 break outo；语句，这行代码将会导致结束 outo 标签指定的循环，不是结束 break 所在的循环，而是结束 break 玄幻的外层循环。

通常紧跟 break 之后的标签，必须在 break 所在的循环的外层循环之前定义才有意义。

4.2 continue 结束本次循环

continue 的功能和 break 有点类似，区别是 continue 只是终止本次循环，接着开始下次循环；而 break 则是完全终止循环本身。可以理解为 continue 的作用是跳过当次循环中剩下的语句，重新开始一次新的循环。例如下面代码。

public class NestedTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是 i = " + i + " 前面的语句");
            if (i <= 3){
                continue;
            }
            System.out.println("我是 i = " + i + " 后面的语句");
        }
    }
}

当 i 小于等于 3 的时候 if 下面的语句没有输出，因为程序走了 if 体里面的 continue ，忽略了当次循环，开始了新循环。

与 break 类似的是，continue 后也可以紧跟一个标签，用于直接跳过标签所在标识循环的当次循环的剩下语句，重新开始下一次循环。例如下面代码。

public class NestedTest {
    public static void main(String[] args) {
        outo:
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j < 5; j++) {
                System.out.println("这人又来 for 循环了~~~");
                if (i * j > 8) {
                    System.out.println("只能执行到这了，下面的就先跳过吧，不用执行了");
                    continue outo;
                }
                System.out.println("内层循环，我是否能被执行到！！！");
            }
            System.out.println("======外层循环，我是否能被执行到！！！");
        }
    }
}

当程序执行到 continue outo 语句时，直接跳过了内层循环和外层循环，执行了外层的下一次循环。

与 break 类似的是，continue 后的标签也必须是一个有效标签，即这个标签通常应该放在 continue 所在循环的外层循环之前定义。

4.3 return 结束方法

return 关键字并不是专门用于结束循环的，return 的功能是结束一个方法。当一个方法执行到 return 语句时（return 关键字后还可以跟变量、常量和表达式，后面会介绍），这个方法将被结束。

例如下面代码会结束改方法。

public class NestedTest {
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            System.out.println("我又在不停的循环中...");
            if (i > 10){
                System.out.println("过分，1 万都不让你循环，你还循环 10 次，做梦，我要终结整个方法。");
                return;
            }
        }
    }
}

上面代码，碰到 return 语句后，程序立马结束，不管循环多少次或多少层。

好了，今天的内容到这里就结束了，关注我，我们下期见

【西行 - 大圣闹天宫】 Java 流程控制