Java 流程控制 - 分支、循环

顺序控制

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

public class Test{
    //正确形式
    int a = 1;
    int b = a;

    // 错误形式
    int c = d + 1;
    int d = 2;
}

块作用域

块（即复合语句）是指由一对大括号括起来的若干条简单的 Java 语句。块确定了变量的作用域。一个块可以嵌套在另一个块中。不能在嵌套的两个块中声明同名的变量。

public static void main(String[] args) {
    int n;
    ...
    {
        int k; 
        // 这里就不能定义变量n了
    } // k的作用域只到这里
}

分支控制

如果判断的具体数值不多，而且符合 byte、short、int、char、enum[枚举]、String 这6种类型，建议使用 swtich语句。

对于区间判断，结果为 boolean 类型判断，建议使用 if，if 的使用范围更广。

单分支 if

if(条件) {
    语句体;
}

当条件表达式为ture时，会执行 { } 中的代码。如果为false，则不执行。如果 { } 中只有一条语句，则可以省略 { }，建议写上。

执行流程：

首先判断条件是true还是false
如果是true就执行语句体
如果是false就不执行语句体

import java.util.Scanner;
public class If01 {
    public static void main(String[] args) {
        // 定义一个scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入大小：");
        // 把大小保存到一个int变量age中
        int size = scanner.nextInt();
        // 使用if判断，输出对应的信息
        if (size >= 18) {
            System.out.println("我的很大，你忍一下");
        }
        System.out.println("程序继续运行....");
        scanner.close();
    }
}

双分支 if…else

if(条件) { 
    语句体1; 
}else { 
    语句体2; 
}

当条件表达式成立，执行语句体1，否则执行语句体2。

执行流程：

首先判断条件是true还是false
如果是true就执行语句体1
如果是false就执行语句体2

import java.util.Scanner;
public class If02 {
    public static void main(String[] args) {
        // 定义一个scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入大小：");
        // 把size保存到一个int变量size中
        int size = scanner.nextInt();
        // 使用if判断，输出对应的信息
        if (size >= 18) {
            System.out.println("我的很大，你忍一下");
        } else {
            System.out.println("吴签");
        }
        System.out.println("程序继续运行....");
        scanner.close();
    }
}

多分支 if…else if …else

if (判断条件1) { 
    执行语句1; 
} else if (判断条件2) { 
    执行语句2; 
} 
... 
}else if (判断条件n) { 
    执行语句n; 
} else { 
    执行语句n+1; 
}

多分支可以没有else，如果所有的条件都不成立则不执行分支中的代码。如果有else，当所有的条件不成立时，则默认执行else代码块中的代码。

执行流程：

首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1。

import java.util.Scanner;
public class If03 {
    public static void main(String[] args) {
        /* 输入张三的信用分，
         * 如果信用分为100，输出信用极好
         * 信用分为(80-99]，输出信用优秀
         * 信用分为(60-80]，输出信用一般
         * 其他情况，输出信用不及格
         */
        // 定义一个scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入信用分数(1-100)：");
        // 把信用分保存到一个int变量grade中
        int grade = scanner.nextInt();
        if (grade >= 1 && grade <= 100) {
            // 使用if判断，输出对应的信息
            if (grade == 100) {
                System.out.println("信用极好");
            } else if (grade > 80 && grade <= 99) {
                System.out.println("信用优秀");
            } else if (grade > 60 && grade <= 80) {
                System.out.println("信用一般");
            } else {
                System.out.println("信用不及格");
            }
            scanner.close();
        } else {
            System.out.println("信用分需要在1-100，请重新输入！");
        }
    }
}

嵌套分支

在一个分支结构中完整的嵌套了另一个完整的分支结构，里面的分支结构成为内层分支，外面的分支结构成为外层分支。建议不要超过3层，可读性不好。

if() {
    if() {
        // if - else ...
    } else {
        // if - else
    }
}

选择语句 switch

switch(表达式) { 
    case 常量值1: 
        语句体1; 
        break; 
    case 常量值2: 
        语句体2; 
        break; 
    ... 
    default: 
        语句体n+1; 
        break; 
}

switch语句中，case后面的值不可以重复，必须是常量，并且类型保持一致或者可以自动转型。
表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
如果case的后面不写break，将出现穿透现象，不会判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
如果都没有匹配上，则执行default中的语句，default也可以不写。

执行流程：

首先计算出表达式的值
和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

import java.util.Scanner;
public class Switch01 {
    public static void main(String[] args) {
        // 请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g
        // a 表示星期一，b 表示星期二 …
        // 根据用户的输入显示相应的信息.要求使用 switch 语句完成
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符(a-g)：");
        char c1 = scanner.next().charAt(0); // .charAt(0) 表示获取第一个字符
        char c2 = 'e';
        switch (c1) {
            case 'a':
                System.out.println("今天是星期一");
                break;
            case 'b':
                System.out.println("今天是星期二");
                break;
            case 'c':
                System.out.println("今天是星期三");
//                break;
                // 会出现穿透情况

            case 'd':
                System.out.println("今天是星期四");
                break;

            // case 后面不能加变量，必须是常量或者常量表达式
//            case c2:
//                System.out.println("今天是星期五");
//                break;

            case 'f':
                System.out.println("今天是星期六");
                break;
                // case后的类型必须和switch表达式中结果的类型一致或者可以自动转成相互比较的类型

                //            case "g":
//                System.out.println("今天是星期日");
//                break;

              // default 语句可以不写
//            default:
//                System.out.println("你输入的字符不对，没有匹配的");
        }
        System.out.println("switch退出了，继续执行程序");
    }
}

循环控制

控制条件语句所控制的变量，在for循环结束后，就不能再被访问，而while循环结束还可以继续使用。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

循环语句 for

for(初始化表达式①; 布尔表达式②; 步进表达式④){ 
    循环体③ 
}

循环结构的基本组成部分，一般可以分成四部分：

初始化语句：在循环开始最初执行，而且只做唯一一次。
条件判断：如果成立，则循环继续；如果不成立，则循环退出。
循环体：重复要做的事情内容，若干行语句。
步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

循环条件是返回一个布尔值的表达式。

for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

执行流程：

执行顺序：①②③④>②③④>②③④…②不满足为止

①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况

package javase;
public class For01 {
    public static void main(String[] args) {
        // 打印10句“我爱你”
        for (int i = 0; i < 10; i++) {
            System.out.println("我爱你" + i);
        }
        // 初始化语句和步进表达式可以不写
        int a = 0;
        for (; a < 10; ) {
            System.out.println("我不爱你" + a);
            a++;
        }
        // 死循环, 可以使用break跳出
        for (; ; ) {
            break;
        }
        // 初始化和步进表达式可以多句，用逗号分隔
        for (int i = 0, j = 0; i < 10; i++, j += 2) {
            System.out.println("i = " + i + ", j = " + j);
        }
    }
}

循环语句 while

初始化表达式① 
while(布尔表达式②){ 
    循环体③ 
    步进表达式④ 
}

while 循环是先判断再执行语句

执行流程：

执行顺序：①②③④>②③④>②③④…②不满足为止。

①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句。
④循环后，循环变量的变化情况。

public class While01 {
    public static void main(String[] args) {
        // 输出10句我爱你
        int i = 1;
        while (i <= 10) {
            System.out.println("我爱你" + i++);
        }
        // 输出1-100能被3整除的数
        int num = 1;
        while (num <= 100) {
            System.out.print(num % 3 == 0 ? num + "  " : "");
            num++;
        }
    }
}

循环语句 do…while

初始化表达式① 
do{ 
    循环体③ 
    步进表达式④ 
}while(布尔表达式②);

do…while 循环先执行，再判断，一定且至少执行一次。最后有个分号。

执行流程：

执行顺序：①③④>②③④>②③④…②不满足为止。

①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句
④循环后，循环变量的变化情况

public class DoWhile01 {
    public static void main(String[] args) {
        // 输出10次我爱你
        int i = 1;
        do {
            System.out.println("我爱你" + i++);
        } while (i <= 10);
        // 统计1-200之间，能被5整除，但不能被3整除的数
        int count = 0;
        i = 1;
        do {
            if (i % 5 == 0 && i % 3 != 0) {
                System.out.print(i + "  ");
                count++;
            }
        } while (++i <= 200);
        System.out.println("count = " + count);

        Scanner scanner = new Scanner(System.in);
        char a;
        do {
            System.out.println("还钱吗？(y/n)");
            a = scanner.next().charAt(0);
            if (a != 'y') {
                System.out.println("抽死你个小王八犊子");
            }
        } while (a != 'y');
    }
}

多重循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中 for，while，do…while 均可以作为外层循环和内层循环。

嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

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

跳出语句

Java 还提供了一种带标签的 break语句，用于跳出多重嵌套的循环语句。标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号。可以将标签应用到任何语句中，甚至可以应用到 if语句或者块语句中。continue同理。

跳出语句出现在多层嵌套的语句块中，可以通过标签指明要跳出的是哪一层语句块。如果没有标签，默认退出最近的循环体。跳出语句后指定哪一个标签，就退出到哪里。

Scanner in = new Scanner(System.in);
int n;
read_data:
while (. . .) // 会跳出这个循环
    for (. . .) { // 不会跳出这个循环
        Systen.out.print("Enter a number >= 0: ");
        n = in.nextlntO;
        if (n < 0) 
            break read_data; // 如果条件成立，则跳出read_data的循环
    }
}
if (n < 0) { // 跳出后开始执行此行
    // 处理不好的情况
} else {
    // 进行正常处理
}

break

break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环 for，while，do-while中。

{
    // 代码
    break; 
    // 代码
}

public class Break01 {
    public static void main(String[] args) {
        // 1-100以内的数求和，当和第一次大于20时的数字是多少
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if ((sum += i) >= 20) {
                System.out.println("当前数是：" + i);
                System.out.println("和是：" + sum);
                break;
            }
        }
        Scanner scanner = new Scanner(System.in);
        for (int i = 2; i >= 0; i--) {
            System.out.print("请输入用户名：");
            String username = scanner.nextLine();
            System.out.print("请输入密码：");
            String password = scanner.nextLine();
            if ("丁真".equals(username) && "666".equals(password)) {
                System.out.println("登陆成功！");
                break;
            } else {
                System.out.println("密码错误！！还有" + i + "次机会");
            }
        }
    }
}

continue

结束本次循环，继续下一次的循环

public class Continue0 {
    public static void main(String[] args) {
        label1:
        for (int i = 0; i < 4; i++) {
            lable2:
            for (int j = 0; j < 5; j++) {
                if (j == 2) {
                    // continue;    该写法和continue lable2;等价
                    // continue lable2;
                    continue label1;
                }
                System.out.println("j = " + j);
            }
        }
    }
}