javaSE_06_控制语句

知识框架

控制语句概述

在大部分编程语言当中都会存在控制语句，控制语句是一个程序的灵魂，我们只依靠“标识符、关键字、变量、运算符”等零散的知识点是无法进行流程控制的，无法实现一个具体的功能或业务，所以控制语句这一章节非常重要。现实生活中哪些业务需要使用控制语句呢？比如说“小孩身高如果高于 1.2 米，则乘坐交通工具就需要收费了，反之则免费”，再比如“A 账户向 B 账户转账 10000 元，首先需要判断 A账户的余额是否大于等于 10000 元，如果余额充足则可以转账，不足则无法转账”等等，这些业务当中都需要使用控制语句进行控制才能完成。什么是控制语句，官方的解释是这样的：控制语句即用来实现对程序流程的选择、循环、转向和返回等进行控制。Java 语言中共有 8 种控制语句，可以分为“选择语句”，“循环语句”，“转向语句”，“返回语句”四类。那么，这 8 种控制语句分别是什么呢？if 语句、switch 语句、for 循环、while 循环、do..while 循环、break 语句、continue 语句、return 语句。其中 if 和switch 语句属于选择语句，for、while、do..while 语句属于循环语句，break 和 continue 语句属于转向语句，return 属于返回语句。流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。 其中Java中的控制语句由三种基本流程语句组成，接下来让我们认真的学习每一个语句。

顺序语句：

• 程序顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

代码演示

/*
    顺序结构
*/
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        
        System.out.println("语句A");
        System.out.println("语句B");
        System.out.println("语句C");
        
        System.out.println("结束");
    }
}

选择语句

选择语句又称为分支语句，它通过对给定的条件进行判断，从而决定执行两个或多个分支中的哪一支。因此，在编写选择语句之前，应该首先明确判断条件是什么，并确定当判断结果为“真”或“假”时应分别执行什么样的操作/算法。在 Java 语言中选择语句主要提供了两个，一个是 if 语句，另一个则是 switch 语句。 

选择语句之if语句

if语句第一种格式： if

格式：

执行流程：

• ①首先计算关系表达式的值
• ②如果关系表达式的值为true就执行语句体
• ③如果关系表达式的值为false就不执行语句体
• ④继续执行后面的语句内容

 if语句流程图

代码演示

/*
    if语句格式1
    格式：
        if (关系表达式) {
            语句体;    
        }
    
    执行流程：
        1:首先计算关系表达式的值
        2:如果关系表达式的值为true就执行语句体
        3:如果关系表达式的值为false就不执行语句体
        4:继续执行后面的语句内容
*/
public class Demo {
    public static void main(String[] args) {
 
        //定义两个变量
        int a = 10;
        int b = 20;
 
        //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
        if (a == b) {
            System.out.println("a等于b");
        }
 
        //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
        int c = 10;
        if (a == c) {
            System.out.println("a等于c");//a等于c
        }
 
        System.out.println("结束");//结束
    }
}

if语句第二种格式： if...else

格式：

执行流程：

• ①首先计算关系表达式的值
• ②如果关系表达式的值为true就执行语句体1
• ③如果关系表达式的值为false就执行语句体2
• ④继续执行后面的语句内容

 if....else语句的执行流程图

代码演示

import java.util.Scanner;
 
/*
    if语句格式2
    格式：
        if (关系表达式) {
            语句体1;
        } else {
            语句体2;
        }
    执行流程：
        1:首先计算关系表达式的值
        2:如果关系表达式的值为true就执行语句体1
        3:如果关系表达式的值为false就执行语句体2
        4:继续执行后面的语句内容
    需求：
        任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
*/
public class Demo {
    public static void main(String[] args) {
        //为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        //获取从外界输入的数字
        int number = sc.nextInt();
        /*
        判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
        判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0    
        根据判定情况，在控制台输出对应的内容
         */
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }
 
    }
}

f语句第三种格式： if...else if ...else

格式：

执行流程：

• ①首先计算关系表达式1的值
• ②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
• ③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
• ④…
• ⑤如果没有任何关系表达式为true，就执行语句体n+1。 

if..else if...else执行流程图

代码演示

/*
    if语句格式3
    格式：
        if (关系表达式1) {
            语句体1;
        } else if (关系表达式2) {
            语句体2;
        }
        …
        else {
            语句体n+1;
        }
    执行流程：
        1:首先计算关系表达式1的值
        2:如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
        3:如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
        4:…
        5:如果没有任何关系表达式为true，就执行语句体n+1。
需求：
小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
    奖励：
        95~100        山地自行车一辆
        90~94        游乐场玩一次
        80~89        变形金刚玩具一个
        80以下        胖揍一顿
*/
import java.util.Scanner;
 
public class Demo {
    public static void main(String[] args) {
        //小明的考试成绩未知，可以使用键盘录入的方式获取值
        Scanner sc = new Scanner(System.in);
 
        System.out.println("请输入一个分数：");
        int score = sc.nextInt();
 
        /*
        由于奖励种类较多，属于多种判断，采用if...else...if格式实现
        为每种判断设置对应的条件
        为每种判断设置对应的奖励
        */
        //数据测试：正确数据，边界数据，错误数据
        if(score>100 || score<0) {
            System.out.println("你输入的分数有误");
        } else if(score>=95 && score<=100) {
            System.out.println("山地自行车一辆");
        } else if(score>=90 && score<=94) {
            System.out.println("游乐场玩一次");
        } else if(score>=80 && score<=89) {
            System.out.println("变形金刚玩具一个");
        } else {
            System.out.println("胖揍一顿");
        }
    }
}

小结选择结构if语句

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
• 当多个条件是“包含”关系时，“小上大下 / 子上父
• 在某些简单的应用中，if语句是可以和三元运算符互换使用的。 三元运算符的执行效率比if语句要高，if语句的适用范围比三元运算符要多的多。
• 对于if语句来说，在任何情况下只能有1个分支执行，不可能存在2个或者更多个分支执行。if语句中只要有1个分支执行了，整个if语句就结束了。
• 凡是带有else分支的，一定可以保证会有一个分支执行。

if语句嵌套，代码举例

public class IfTest02 {
    public static void main(String[] args) {
        // 接收用户键盘输入
        java.util.Scanner s = new java.util.Scanner(System.in);
        // 提示信息
        System.out.print("请输入您的性别，输入1表示男，输入0表示女：");
        // 程序停下来等待用户的输入
        int gender = s.nextInt();
        // 提示信息
        System.out.print("请输入当前的天气，1表示雨天，0表示晴天：");
        // 等待用户的输入
        int weather = s.nextInt();
        if (weather == 1) {
            //System.out.println("雨天");
            if (gender == 1) {
                // 男
                System.out.println("下雨了，小哥哥，出门的时候记得拿一把大黑伞哦！");
            } else if (gender == 0) {
                // 女
                System.out.println("下雨了，小姐姐，出门的时候记得带一把小花伞哦！");
            }
        } else if (weather == 0) {
            //System.out.println("晴天");
            if (gender == 1) {
                // 男
                System.out.println("外面的天气不错，老铁们出去玩耍吧！");
            } else if (gender == 0) {
                // 女
                System.out.println("外面的天气晴朗，小姐姐要保护好皮肤哦，擦点防晒霜！");
            }
        }
    }
}

选择语句之switch语句

格式：

执行流程

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

switch执行流程示意图

示例代码

/*
题目：
        1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。

        2、等级：
            优：[90~100]
            良：[80~90) 
            中：[70-80)
            及格：[60~70)
            不及格：[0-60)

        3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。

        必须使用switch语句来完成，你该怎么办？
*/
public class SwitchTest02{
    public static void main(String[] args){
        // 提示用户输入学生成绩
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入学生成绩：");
        double score = s.nextDouble();
        if(score < 0 || score > 100){
            System.out.println("您输入的学生成绩不合法，再见！");
            return; // 这个代码的执行，会让main结束。
        }
        int grade = (int)(score / 10); // 95.5/10结果9.55，强转为int结果是9
        String str = "不及格";
        switch(grade){
            case 10: case 9:
                str = "优";
                break;
            case 8:
                str = "良";
                break;
            case 7:
                str = "中";
                break;
            case 6:
                str = "及格";
        }
        System.out.println("该学生的成绩等级为：" + str);
    }
}

case的穿透性：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。代码举例

import java.util.Scanner;
 
/*
    switch语句
    格式：
        switch(表达式) {
            case 值1：
            语句体1;
            break;
            case 值2：
            语句体2;
            break;
            …
            default：
            语句体n+1;
            [break;]
        }
    格式说明：
        表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
        case：后面跟的是要和表达式进行比较的值。
        break：表示中断，结束的意思，用来结束switch语句。
        default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
    执行流程：
        首先计算表达式的值。
        依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
        如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。
需求：
一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
                春：3、4、5
                夏：6、7、8
                秋：9、10、11
                冬：1、2、12
*/
public class Demo {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch (month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

switch语句有关规则

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；switch 虽然只能探测 int 类型，但是也可以将 byte,short,char 类型放到小括号当中，因为这些类型会自动转换成 int 类型（小容量向大容量转换称为自动类型转换）。 
• case子句中的值必须是常量，不能是变量名或不确定的表达式值；
• 同一个switch语句，所有case子句中的常量值互不相同；
• break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default
• case的穿透性：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。 

循环语句之一：for循环

格式：

执行流程：

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

• ①负责完成循环变量初始化。初始化部分(init_statement)：在循环开始最初执行，而且只做唯一一次。初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• ②负责判断是否满足循环条件，不满足则跳出循环。循环条件部分(test_exp) ：如果成立，则循环继续；如果不成立，则循环退出。循环条件部分必须是boolean类型表达式，当值为false时，退出循环
• ③具体执行的语句。循环体部分(body_statement)：重复要做的事情内容，若干行语句。
• ④循环后，循环条件所涉及变量的变化情况。迭代部分(alter_statement)：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。可以有多个变量更新，用逗号分隔。

for循环代码执行示意图

代码示例

/*
    for语句
    格式：
        for(初始化语句;条件判断语句;条件控制语句) {
            循环体语句;
        }
    执行流程：
        1:执行初始化语句
        2:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        3:执行循环体语句
        4:执行条件控制语句
        5:回到2继续
 */
/*
    统计
    
    需求：
        统计"水仙花数"一共有多少个，并在控制台输出个数
*/
public class Demo {
    public static void main(String[] args) {
        //定义变量count，用于保存“水仙花数”的数量，初始值为0
        int count = 0;
 
        //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
        for (int i = 100; i < 1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;
 
            //在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                count++;
            }
        }
 
        //打印输出最终结果
        System.out.println("水仙花共有：" + count + "个");
    }
}

for循环有各种变形，如下所示

/*
    1、for循环的语法机制以及运行原理？
        语法机制：
            for(初始化表达式; 条件表达式; 更新表达式){
                循环体; // 循环体由java语句构成

            }
            注意：
                第一：初始化表达式最先执行，并且在整个循环中只执行一次。
                第二：条件表达式结果必须是一个布尔类型，也就是：true或false
            执行原理：
                先执行初始化表达式，并且初始化表达式只执行1次。
                然后判断条件表达式的结果，如果条件表达式结果为true，
                则执行循环体。
                循环体结束之后，执行更新表达式。
                更新完之后，再判断条件表达式的结果，
                如果还是true，继续执行循环体。

                直到更新表达式执行结束之后，再次判断条件时，条件为false，
                for循环终止。
            
            更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新
            某个变量的值，这样条件表达式的结果才有可能从true变成false，从而
            终止for循环的执行，如果确实更新表达式，很有可能会导致死循环。

*/
public class ForTest02{
    public static void main(String[] args){


        // 最常见的for循环
        // 循环10次，输出0~9
        /*
        
            强调一下：对于以下的这个for循环，其中int i = 0;
            最先执行，并且只执行一次，而且i变量属于for循环
            的局部变量，for循环结束之后i的内存就释放了。
            这个i变量只能在for循环中使用。
            这个i变量属于for循环域。在main方法中没有办法直接使用。
        */
        for(int i = 0;i < 10;i++){
            System.out.println("i = " + i); // 0 1 2 3....9
        }

        //错误: 找不到符号
        //System.out.println(i);

        // i变量的作用域就扩大了。
        int i = 0;
        for(;i < 10;i++){
            System.out.println("i --> " + i); // 0 1 2 3....9
        }
        System.out.println("这里的i可以访问吗？i = " + i); // 这里的i可以访问吗？i = 10
        // 变形
        for(int k = 1; k <= 10; k++){
            System.out.println("k --> " + k); // 1 2 ..... 9 10
        }

        // 变形
        for(int k = 1; k <= 10; ){
            System.out.println("k --> " + k);  // 1 2 ..... 9 10
            k++;
        }

        // 变形
        for(int k = 1; k <= 10; ){
            k++;
            System.out.println("value --> " + k); // 2 3 4 5 6 7 8 9 10 11
        }

        // for的其它形式
        for(int a = 10; a > 0; a--){
            System.out.println("a = " + a); // 10 9 8 7 6 5 4 3 2 1
        }

        // 变形
        for(int b = 0; b < 10; b += 2){
            System.out.println("b = " + b); // 0 2 4 6 8
        }

    }
}

for循环嵌套

所谓嵌套循环，是指一个循环的循环体是另一个循环。将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环。请反复理解这句话：整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的。结论：外循环执行一次，内循环执行一圈 

格式：

   

嵌套循环执行流程：

• 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
• 外循环一次，内循环多次。

/*
1、所有合法的“控制语句”都可以嵌套使用。
2、for循环嵌套一个for循环执行原理是什么？
    提示一下：大家不要因为for循环中嵌套了一个for循环，就感觉
    这个程序比较特殊，实际上大家可以这样看待：
        for(){
            //在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码.
            for(){}
        }
*/
public class ForTest02 {
    public static void main(String[] args) {

        // 单层for循环
        for (int i = 0; i < 2; i++) {
            System.out.println("i = " + i);
        }

        for (int k = 0; k < 2; k++) { // 循环2次
            for (int i = 0; i < 3; i++) {
                System.out.println("i ---> " + i);
            }
        }
    }

}

循环语句之二：while 循环

格式：

执行流程

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

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

while循环代码执行示意图

代码举例

/*
     while循环：
        1、while循环的语法机制以及执行原理
            语法机制：
                while(布尔表达式){
                    循环体;
                }
            执行原理：
                判断布尔表达式的结果，如果为true就执行循环体，
                循环体结束之后，再次判断布尔表达式的结果，如果
                还是true，继续执行循环体，直到布尔表达式结果
                为false，while循环结束。

        2、while循环有没有可能循环次数为0次？
            可能。
            while循环的循环次数是：0~n次
 */
public class Demo {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;

        //定义纸张厚度
        double paper = 0.1;

        //定义珠穆朗玛峰的高度
        int zf = 8844430;

        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while (paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;

            //在循环中执行累加，对应折叠了多少次
            count++;
        }

        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");//需要折叠：27次
    }
}

循环语句之三：do...while

格式：

执行流程

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

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

do...while 代码执行示意图

示例：

/*
    do...while语句
    基本格式：
        do {
            循环体语句;
        }while(条件判断语句);
        
    完整格式：
        初始化语句;
        do {
            循环体语句;
            条件控制语句;
        }while(条件判断语句);
    执行流程：        
        1:执行初始化语句
        2:执行循环体语句
        3:执行条件控制语句
        4:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        5:回到2继续
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        
        //do...while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j<=5);
        
    }
}

三种循环的区别

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
• do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

for循环和while的区别

• 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
• 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
• 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

死循环

死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

死循环（无限循环）的三种格式

• for(;;){}
• while(true){}
• do {} while(true);

代码示例

/*
永远停不下来的循环，叫做死循环。最常用的死循环的标准格式：
while (true) {
    循环体
}
*/
public class DemoDeadLoop {
    public static void main(String[] args) {
        while (true) {
            System.out.println("I Love Java!");
        }
        
        // System.out.println("Hello"); 错误，永远执行不到的代码，不能编写
    }
}

程序流程控制关键字

关键字：break

• 用在switch语句当中，一旦执行，整个switch语句立刻结束。
• 用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。

代码示例：

/*
    break;语句：
        1、break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。
        另外：continue也是这样，他俩都是一个单词成为一条语句。

        2、break 翻译为折断、弄断。

        3、break;语句可以用在哪里呢？
            用在两个地方，其它位置不行
            第一个位置：switch语句当中，用来终止switch语句的执行。
                用在switch语句当中，防止case穿透现象，用来终止switch。

            第二个位置：break;语句用在循环语句当中，用来终止循环的执行。
                用在for当中
                用在while当中
                用在do....while..当中。
        
        4、以下程序主要是以for循环为例学习break转向语句。

        5、break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近
        的那个循环语句。

        6、怎么用break;语句终止指定的循环呢？
            第一步：你需要给循环起一个名字，例如：
                a: for(){
                    b:for(){
                    
                    }
                }
            第二步：终止：break a;
*/
public class BreakTest01{

    public static void main(String[] args){

        

        for(int i = 0; i < 10; i++){
            if(i == 5){
                // break;语句会让离它最近的循环终止结束掉。
                break; // break;终止的不是if，不是针对if的，而是针对离它最近的循环。
            }
            System.out.println("i = " + i); // 0 1 2 3 4
        }

        // 这里的代码照常执行。break;的执行并不会影响这里。
        System.out.println("Hello World!");

        // 这个for循环两次
        for(int k = 0; k < 2; k++){ // 外层for
            for(int i = 0; i < 10; i++){ // 内层for
                if(i == 5){
                    break; // 这个break;语句只能终止离它最近的for
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("------------------------------------------");

        // 以下讲解的内容，以后开发很少用。不要紧张。
        // 这种语法很少用，了解一下即可。
        a:for(int k = 0; k < 2; k++){ 
            b:for(int i = 0; i < 10; i++){
                if(i == 5){
                    break a; // 终止指定的循环。
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("呵呵");

    }
}

关键字：continue 

• continue只能使用在循环结构中
• continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环

代码示例：

/*
    continue;语句：
        continue翻译为：继续
        continue语句的作用是：
            终止当前"本次"循环，直接进入下一次循环继续执行。
            for(){
                if(){ // 当这个条件成立时，执行continue语句
                    continue; //当这个continue语句执行时，continue下面的代码不执行，直接进入下一次循环执行。
                }
                // 以上的continue一旦执行，以下代码不执行，直接执行更新表达式。
               code1
            }

        4、continue语句后面可以指定循环吗？
            可以的。
            这里就不再讲了，自己测试以下。
            a:for(;;更新表达式1){
                b:for(;;更新表达式2){
                    if(){
                        continue a;
                    }
                    code1;
                
                }
            }
*/
public class ContinueTest01{
    public static void main(String[] args){

        for(int i = 0; i < 10; i++){
            if(i == 5){
                break;
            }
            System.out.println("i = " + i);
        }

        System.out.println("----------------------------");
        
        for(int i = 0; i < 10; i++){
            if(i == 5){
                continue;
            }
            System.out.println("i = " + i); 
        }

    }
}

特殊流程控制语句说明

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。