三、第三章——控制语句之选择结构语句、循环语句、改变控制语句的顺序

控制语句

java控制语句可以分为7种：
    选择结构语句
        if、if else
        switch
​
    循环语句
        for
        while
        do while
​
    改变控制语句顺序
        break
        continue

 

1 选择结构

1.1 选择结构语句if

关于java语言当中的if语句，属于选择结构，if语句又被称为分支语句/条件控制语句：
    1、if语句的语法结构：四种编写方式
        第一种：
            if(布尔表达式){
                java语句;
                java语句;
                ...
            }
​
        第二种：
            if(布尔表达式){
                java语句;
                java语句;
                ...
            }else{
                java语句;
                java语句;
                ... 
            }
​
        第三种：
            if(布尔表达式){
                java语句;
                java语句;
                ...
            }else if(布尔表达式){
                java语句;
                java语句;
                ...
            }else if(布尔表达式){
                java语句;
                java语句;
                ...
            }......
        
        第四种：
            if(布尔表达式){
                java语句;
                java语句;
                ...
            }else if(布尔表达式){
                java语句;
                java语句;
                ...
            }else if(布尔表达式){
                java语句;
                java语句;
                ...
            }else{
                java语句;
                java语句;
                ...
            }
​
    2、重点：对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束。
​
    3、注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行。
​
    4、所有的控制语句都是可以嵌套使用的。只要合理嵌套就行。
        if(){
            if(){
                if(){
​
                }
            }
        }else{
            if(){
​
            }else{
                if(){
                    if(){
​
                    }
                }
            }
        }
​
        注意：嵌套使用的时候，代码格式要保证完美。 【该缩进的时候必须缩进】
        
    5、if语句的分支中只有一条java语句的话，大括号可以省略不写。
        if(true/false){
            一条java语句;
        }
        //这种方式不推荐使用，别人这么写能看懂就行。
        if(true) 一条java语句;
​
​
public class IfTest01
{
    public static void main(String[] args){
        //需求：所在位置的五公里范围之内有肯德基的话，去KFC吃午饭
        //公里数
        double distance = 3.0;  //单位KM
        //判断语句
        if(distance < 5){
            System.out.println("支KFC吃菜");
        }
​
        /*
            需求：
                假设系统给定一个考生的成绩，成绩可能带有小数点，根据学生的成绩判断该学生的成绩等级：
                    [90-100] A
                    [80-90)  B
                    [70-80)  C
            [60-70)  D
[0-60)   E
以上的逻辑判断采用if语句完成，应该怎么写？
*/
        
/*
double score = 87.8;
if(score >= 90 && score <= 100){
System.out.println('A');
}else if(score >= 80){
System.out.println('B');
}else if(score >= 70){
System.out.println('C');
}else if(score >= 60){
System.out.println('D');
}else if(score >= 0){
System.out.println('E');
}else{
System.out.println("成绩不规范!");
}
*/
​
double score = 58.8;
//使用以下这种方式可以完成需求，但是这种方式效率较低。每一个if都是不相关的，都是独立的，每一个if都会判断一次。
/*
if() {
​
}
​
if() {
​
}
​
if() {
​
}
​
if() {
​
}
*/
​
//根据需求决定选择以上的第四种结构来完成需求
/*
if(score < 0 || score > 100){
System.out.println("考生成绩不合法");
}else if(score >= 90){  //没必要判断是否小于等于100，能执行到这里一定是小于100的
System.out.println("A");
}else if(score >= 80){
System.out.println("B");
}else if(score >= 70){
System.out.println("C");
}else if(score >= 60){
System.out.println("D");
}else{
System.out.println("E");
}
*/
​
String grade = "E";
if(score < 0 || score > 100){
grade = "考生成绩不合法";
    }else if(score >= 90){  //没必要判断是否小于等于100，能执行到这里一定是小于100的
grade = "A";
    }else if(score >= 80){
grade = "B";
    }else if(score >= 70){
grade = "C";
    }else if(score >= 60){
grade = "D";
    }else{
grade = "E";
    }
System.out.println(grade);
    }
}

 

1.2 选择结构语句if

/*
    需求：
        假设系统给定一个人的年龄(这个年龄需要从键盘输入)，根据年龄来判断这个人处于生命的哪个阶段，年龄必须在[0~150]
        [0-5] 幼儿
        [6-10] 少儿
        [11-18] 青少年
        [19-35] 青年
        [36-55] 中年
        [56-150] 老年
*/
​
public class IfTest02
{
    public static void main(String[] args){
        //1、接收键盘输入：年龄 【输入的时候必须输入数字】
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入你的年龄: ");  //输出提示信息，要不然用户根本不知道这里要干嘛
        int age = s.nextInt();  //停下来等待用户的输入，输入之后自动获取，赋值给age
        // System.out.println("age = " + age);
​
        //2、根据需求进行业务逻辑判断
        String str = "老年";
        if(age < 0 || age > 150){
            str = "您提供的年龄不合法，年龄值需要在[0-150]之间";
        }else if(age <= 5){
            str = "幼儿";
        }else if(age <= 10){
            str = "少儿";
        }else if(age <= 18){
            str = "青少年";
        }else if(age <= 35){
            str = "青年";
        }else if(age <= 55){
            str = "中年";
        }
​
        if(age >=0 && age <= 150){
            System.out.println("您处于生命周期的" + str + "阶段");
        }else{
            System.out.println(str);
        }       
    }
}

 

1.3 选择结构语句if

需求：
    判断当前的天气：
        当外边下雨的时候：
            带雨伞：
                判断性别：
                    当性别为男：带一把大黑伞
                    当性别为女：带一把小花伞
​
        当外边是晴天的时候：
            判断天气的温度：
                当天气温度在30度以上：
                    当性别为男：戴墨镜
                    当性别为女：擦防晒霜
提示：
    1、一定会用到嵌套
    2、天气状况、温度、性别都需要从键盘输入。
        天气状况：1表示下雨、0表示晴天
        温度直接使用数字即可
        性别：1表示男、0表示女
​
​
public class IfTest03
{
    public static void main(String[] args){
​
        java.util.Scanner s = new java.util.Scanner(System.in);
​
        System.out.println("欢迎使用本系统，您通过本系统可以完成一些简单的判断");
        System.out.println("说明1：1表示下雨，0表示晴天");
        System.out.println("说明2：1表示男，0表示女");
        System.out.println("说明3：温度为数字");
​
        //接收性别
        System.out.print("请输入性别: ");
        int sex = s.nextInt();
​
        //接收天气的状况
        System.out.print("请输入当前天气状况: ");
        int weather = s.nextInt();
​
        //判断天气状况
        if(weather == 1){
            //下雨天
            // System.out.println("下雨天");
            if(sex == 1){
                System.out.println("带一把大黑伞");
            }else if(sex == 0){
                System.out.println("带一把小花伞");
            }else{
                System.out.println("对不起，您的性别是怎么回事?");
            }
        }else if(weather == 0){
            //晴天
            // System.out.println("晴天");
            //接收温度
            System.out.print("请输入当前天气的温度: ");
            int tem = s.nextInt();
            if(tem >= 30){
                if(sex == 1){
                    System.out.println("戴墨镜");
                }else if(sex == 0){
                    System.out.println("擦防晒霜");
                }else{
                    System.out.println("对不起，您的性别是怎么回事?");
                }
            }
        }else{
            System.out.println("你输入的天气状况不存在");
        }
    }
}

 

1.4 选择结构语句if

public class IfTest04
{
    public static void main(String[] args){
        boolean sex = true;
​
        if(sex){
            System.out.println('男');
        }else{
            System.out.println('女');
        }
​
        if(sex) System.out.println('男'); else System.out.println('女');
​
        if(sex)
            System.out.println('男');
            System.out.println("呵呵");
        else
            System.out.println("女");
        //以上程序编译错误出现在19行。26行以上没有语法错误，会在26行处报错：else没有if
    }
}

 

 

1.5 switch基本语法结构

1、switch语句也属于选择结构，也是分支语句
​
2、switch语句的语法结构：
    switch(int或String类型的字面值或变量){
        case int或String类型的字面值或变量 :
            java语句;
            ...
            break;
        case int或String类型的字面值或变量 :
            java语句;
            ...
            break;
        case int或String类型的字面值或变量 :
            java语句;
            ...
            break;
        case int或String类型的字面值或变量 :
            java语句;
            ...
            break;
        ...
        default :
            java语句;
            ...
    }
​
3、switch语句的执行原理：
    - switch后面小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。
    - 按照自上而下的顺序依次匹配。
​
4、匹配成功的分支执行，分支当中最后有“break;”语句的话，整个switch语句终止
​
5、匹配成功的分支执行，分支当中没有“break;”语句的话，直接进入下一个分支执行（不进行匹配）。这种现象被称为case穿透现象。 【提供break;语句可以避免穿透】
​
6、所有分支都没有匹配成功，当有default语句的话，会执行defalut中的语句。
​
7、switch后面和case后面只能是int或者String类型的数据，不能是其他类型
    * 当然byte，short，char也可以直接写在switch和case后面，因为它们可以自动类型转换成int
    * JDK6的，switch和case后面只能探测int类型。
    * JDK7之后包括7版本在内，引入新特性，switch关键字和case关键字后面可以探测int或String类型的数据
​
8、case可以合并:
    int i = 10;
    switch(i){
        case 1: case 2: case 3: case 10:
            System.out.println("Test Code!");
    }

 

1.6 switch基本练习

public class SwitchTest01
{
    public static void main(String[] args){
​
        /*
        long a = 10L;
        int b = a;  //编译报错   
        */
​
        /*
        long x = 100L;
        switch(x){  //编译报错
        }
        */
​
        //解决编译错误
        long x = 100L;
        switch((int)x){}
​
        byte b = 10;
        switch(b){}
​
        short s = 10;
        switch(s){}
​
        char c = 'A';
        switch(c){}
​
        char cc = 97;
        switch(cc){}
​
        //编译报错
        // switch(true){}
​
        String username = "lisi";
        switch(username){}
​
        /*
            较完整的switch语句
        */
        //接收用户输入：
        //1 表示星期一
        //2 表示星期二
        //...
        //7 表示星期日
        java.util.Scanner s1 = new java.util.Scanner(System.in);
        System.out.print("请输入数字: ");
        int num = s1.nextInt();
        switch(num){
            case 1 :
                System.out.println("星期一");
                break;
            case 2 :
                System.out.println("星期二");
                break;
            case 3 :
                System.out.println("星期三");
                break;
            case 4 :
                System.out.println("星期四");
                break;
            case 5 :
                System.out.println("星期五");
                break;
            case 6 :
                System.out.println("星期六");
                break;
            case 7 :
                System.out.println("星期日");
                break;
            default :
                System.out.println("对不起，你输入的数字非法");
        }
​
        //case穿透
        System.out.println("=============================");
        switch(num){
            case 1 :
                System.out.println("星期一");
            case 2 :
                System.out.println("星期二");
            case 3 :
                System.out.println("星期三");
            case 4 :
                System.out.println("星期四");
            case 5 :
                System.out.println("星期五");
            case 6 :
                System.out.println("星期六");
            case 7 :
                System.out.println("星期日");
 default :
System.out.println("对不起，你输入的数字非法");
    }
​
//case合并
switch(num){
case 1: case 0:
System.out.println("星期一");
break;
case 2 :
System.out.println("星期二");
break;
case 3 :
System.out.println("星期三");
break;
case 4 :
System.out.println("星期四");
break;
case 5 :
System.out.println("星期五");
break;
case 6 :
System.out.println("星期六");
break;
case 7 :
System.out.println("星期日");
break;
default :
System.out.println("对不起，你输入的数字非法");
    }
​
    }
}

/*
    switch确实可以探测String类型，这是java7的特性
*/
​
​
public calss SwitchTest02
{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入星期几： ");
        String dayOfWeek = s.next();
        switch(dayOfWeek){
            case "星期一" : 
                System.out.println(1);
                break;
            case "星期二" :
                System.out.println(2);
                break;
            default :
            System.out.println("对不起，您输入的数据非法");
        }
    }
}

public class SwitchTest03
{
    public static void main(String[] args){
        // char c = 'A';
        char c = 'B';
        // char c = 'C';
        // char c = 65;
        // char c = 'D';
​
        switch(c){
            case 'A' :
                System.out.println("高级");
                break;
            case 'B' :
                System.out.println("中级");
                break;
            default :
                System.out.println("出错了");
        }
​
        switch(c){
            case 'A' :
                System.out.println("高级");
                break;
            case 66 :
                System.out.println("中级");
                break;
            default :
                System.out.println("出错了");
        }
    }
}

/*
    实现计算器当中的
        +
        - 
        *
        /
        %
​
    实现思路：
        1、选择所有数据从键盘输入
        2、使用swtich语句进行判断
        3、需要从控制台输入三次：
            * 第一个数字
            * 第二个运算符
            * 第二个数字
​
    最终的控制台上是这样的一个场景：
        欢迎使用简单计算器系统：
        请输入第一个数字：10
        请输入运算符：+
        请输入第二个数字：20
        运算结果：10 + 20 = 30
*/
​
public class SwitchTest04
{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("欢迎使用简单计算器系统");
​
        System.out.print("请输入第一个数字");
        int num1 = s .nextInt();
​
        System.out.print("请输入一个运算符");
        String operator = s.next();
​
        System.out.print("请输入第二个数字");
        int num2 = s.nextInt();
        int result = 0;
​
        switch (operator)
        {
            case "+" :
                result = num1 + num2;
                break;
            case "-" :
                result = num1 - num2;
                break;
            case "*" :
                result = num1 * num2;
                break;
            case "/" :
                result = num1 / num2;
                break;
            case "%" :
                result = num1 % num2;
                break;
            default :
                System.out.println("该系统暂时不支持该运算");
​
        }
​
        System.out.println(num1 + operator + num2 + " = " + result);
    }
}

/*
    假设系统给定考生成绩，请判断该考生的成绩等级：
        1、有效成绩范围： [0-100]
​
        2、考试成绩可以带有小数
​
        3、考试成绩和等级之间的对照关系：
            [90-100]    A
            [80-90)     B
            [70-80)     C
            [60-70)     D
            [0-60)      E
​
        4、以上需求必须采用switch语句完成，不能采用if。
​
        窍门：(int)(成绩 / 10)
            0
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
*/
​
public class SwitchTest05
{
    public staic void main(String[] args){
        //考生成绩
        double score = 95.5;
​
        //转换成int
        int grade = (int)(score / 10);
​
        switch(grade){
            case 9 : case 10 :
                System.out.println("A");
                break;
            case 8 :
                System.out.println("B");
                break;
            case 7 :
                System.out.println("C"):
                break;
            default :
                System.out.println("E");
        }
    }
}

 

2 循环结构

2.1 for循环语法

1、循环结构：
    在程序当中总有一些代码需要反复的/重复的执行，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数编程语言都是支持循环结构的。将来把需要反复执行的代码片段放到“循环体”，再联合“计数器”，共同控制这段需要反复执行的代码循环
​
2、基本上所有的编程语言支持的循环包括三种：
    * for循环
    * while循环
    * do...while循环
​
3、当前示例主要讲解for循环。for循环的语法结构是什么呢？
    语法结构：
        for( 初始化表达式 ; 布尔表达式 ; 更新表达式 ){
            //需要重复执行的代码片段 【循环体：由java语句构成】
        }
​
4、for循环的执行过程/执行原理？ 【*****】
    4.1、初始化表达式、布尔表达式、更新表达式都不是必须的！ 【但是两个分号是必须的】
    4.2、初始化表达式最先执行，并且在整个for循环当中只执行一次。
    4.3、布尔表达式的结果必须是true/false，不能是其它值。
    4.4、for的执行过程：
        * 先执行初始化表达式，并且该表达式只执行一次
        * 判断布尔表达式的结果是true还是false
            - 布尔表达式true
                * 执行循环体
                * 更新表达式
                * 判断布尔表达式的结果是true还是false
                    - 布尔表达式true
                        * 执行循环体
                        * 执行更新表达式
                        * 判断布尔表达式的结果是true还是false
                        ...
                    - 布尔表达式false
                        * 循环结束
            - 布尔表达式false
                * 循环结束
​
​
public class ForTest01
{
    public static void main(String[] args){
        //需求：输出数字1~10
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println(6);
        System.out.println(7);
        System.out.println(8);
        System.out.println(9);
        System.out.println(10);
​
        //使用循环结构来代替以所要反复执行的代码块。
        //使用循环语句可以让代码量变少。
        //将以上代码修改为for循环
        for(int i = 1; i <= 10; i = i + 1){
            System.out.println(i);
        }
​
        for(int i = 1; i <= 10; i += 1){
            System.out.println(i);
        }
​
        for(int i = 1; i <= 10; i++){
            System.out.println(i);
        }
​
        //死循环
        for(;;){
            System.out.println("爱你");
        }
    }
​
}

 

2.2 for循环知识点及练习

public class ForTest02
{
    public static void main(String[] args){
​
        for(int i = 0; i < 10; i ++){
            System.out.println(i);
        }
​
        //以下的for循环当中“i”变量的作用域是仅限于当前for循环内部使用
        for(int i = 0; i <= 10; i++){
            System.out.println(i);
        }
​
        //这个i变量可以在main方法的作用域当中访问吗？无法访问
        //System.out.println(i);  //编译错误
​
        //main方法作用域当中的i变量，只要main方法没有结束，这里的i就能用
        int i = 0;
        for(; i < 10; i ++){
            System.out.println(i);
        }
​
        //这里可以访问main方法作用域当中的i变量
        System.out.println(i);  //10
​
        int j ;
        for(j = 1; j < 10; j ++){
            System.out.println(j);  //10
        }
    }
}

public class ForTest03
{
    public static void main(String[] args){
​
        //输出1~10中的所有的奇数
        for(int i = 1; i <= 10; i += 2){
            System.out.println(i);  //1 3 5 7 9
        }
​
        //输出1~10中的所有的偶数
        for(int i = 2; i <= 10; i += 2){
            System.out.println(i);  //2 4 6 8 10
        }
​
        for(int i = 10; i > 0; i --){
            System.out.println(i);  //10 9 8 7 6 5 4 3 2 1
        }
​
        for(int i = 0; i < 10;){
            System.out.println(i);  //1 2 3 4 5 6 7 8 9
            i ++;
        }
​
        for(int i = 0; i < 10){
            i ++;
            System.out.println(i);  //1 2 3 4 5 6 7 8 9 10
        }
    }
}
​

/*
    循环语句和条件判断语句嵌套使用 【for和if的嵌套】
*/
​
public class ForTest04
{
    public static void main(String[] args){
        //找出1~100中所有的奇数
        //第一种方案：从1开始，每次递增2，这样每一个数字一定是奇数
        // for(int i = 1; i <= 100; i += 2){
        //  System.out.println(i);
        // }
​
        //第二种方案：从1开始，以1递增，每一个数据都进行判断，判断标准是该数字对2求余
        for(int i = 1; i <= 100; i ++){
            if(i % 2 != 0){
                System.out.println(i);
            }
        }
​
        //以上两种方案，优先选择第一种方案：代码少，循环次数少，效率高
    }
}

 

2.3 for循环嵌套for循环

/*
    for循环嵌套for循环
*/
​
public class ForTest06
{
    public static void main(String[] args){
        for(int i=1; i <= 10; i++){
            //循环体中可以编写其它的控制语句
            //控制语句可以嵌套使用
            //控制语句可以是：if、if...else、switch、for、while
            /*
            if(){
                for(){
                    while(){
                        if(){
                            for(){}
                        }
                    }
                }
            }
            */
​
            //最好不要想太多，即使循环体当中是一个for循环，不要将这个for特殊化，也只是一个普通的for循环
            //只不过是一段符合java语法的代码
​
            //内层循环，内层循环中的变量名和外层循环中的变量名不能重名。
            /*
            for(int i = 100 ; ;){
    
            }
            */
​
            //System.out.println(i);
            //这里是循环体，无论这个循环体当中编写了什么样的代码，这堆代码也需要执行10遍
            for(int j = 0; j < 3; j++){
                System.out.println(j);
            }
​
        }
    }
}
​

public class ForTest07
{
    public static void main(String[] args){
​
        for(int i = 1; i < 10; i++){
            for(int j = 0; j < 1; j++){
                System.out.println(j);
            }
        }
​
        for(int i = 1; i <= 5; i++){
            System.out.println("开始");
            for(int j = 1; j <= 5; j++){
                System.out.println(i * j);
            }
            System.out.println("结束");
        }
    }
}

/*
    使用for循环输出九九乘法表：
    1*1=1
    2*1=2 2*2=4
    3*1=3 3*2=6 3*3=9
    4*1=4 4*2=8 4*3=12 4*4=16
    ...
    9*1=9 ... 9*9=81
    
*/
​
public class ForTest08
{
    public static void main(String[] args){
        for(int i = 1; i <= 9; i++){  //外层循环9次
            //i是行号
            // System.out.println(i);
​
            //循环体当中的程序主要的任务是什么？
            //处理当前行，将当前行中所有的项目全部输出
            //4*1=4 4*2=8 4*3=12 4*4=16
            for(int j = 1; j <= i; j++){
                System.out.print(j + "*" + i + "=" + i * j + " ");
            }
            System.out.println();
        }
    }
}

 

2.4 while循环语法

1、while循环的语法结构
    while(布尔表达式){
        循环体;
    }
​
2、while循环的执行原理：
    先判断布尔表达式的结果：
        * true
            - 执行循环体
                * 判断布尔表达式的结果：
                    - true
                        - 执行循环休
                            * 判断布尔表达式的结果：
                                * true
                                    ...
                                * false
                                    -循环结棍
                    - false 
                        - 循环结束
        * false
            - 循环结束
​
3、while循环的循环次数：
    0 ~ N次
    注意：while循环的循环体可能执行次数为0次
​
​
public class WhileTest01
{
    public static void main(String[] args){
        //死循环
        while(true){
            System.out.printlin('1')
        }
        //编译器检测到该程序永远无法被执行，所以编译报错。
        System.out.println("Hello World!");
​
        int i = 10;
        int j = 3;
        //编译通过
        /*
        while(i > j){
            System.out.println("jjj");
        }
        */
​
        /*
        while(10 > 3){
            System.out.println("jjj");
        }   
        //编译错误  
        System.out.println("Helloworld");
        */
    }
​
}

 

2.5 while循环练习

/*
    使用while循环输出1-10
*/
​
public class WhileTest02
{
    public static void main(String[] args){
        int i = 1;
        while(i <= 10){
            System.out.println(i);  //1 2 3 4 5 6 7 8 9 10
            i++;
        }
        System.out.println(i);  //11
​
        int j = 100;
        while(j > 0){
            System.out.println(j--);  //10 9 8 7 6 5 4 3 2 1            
        }
        System.out.println(j);  //0
​
        int k = 10;
        while(k >= 0){
            System.out.println(--k);  //9 8 7 6 5 4 3 2 1 0 -1
        }
        System.out.println(k)  //-1
    }
}

 

2.6 do...while循环结构

1、do...while循环的语法结构
    do{
        循环体;
    }while(布尔表达式);
​
2、do...while循环的执行原理：
    先执行do里面的循环体，然后判断布尔表达式，为真继续执行do里面的循环体，否则退出循环。
​
3、do...while循环的执行次数：
    do...while循环的循环体代码片段执行次数是：1~N次
​
4、使用do...while循环的注意事项：
    do...while循环语句最终有一个“分号”别丢了。
​
​
public class DoWhileTest01
{
    public static void main(String[] args){
        int i = 10;
​
        do{
            System.out.println(i);
        }while(i > 100);
​
        System.out.println("----------------");
​
        while(i > 100){
            System.out.println(i);
        }
​
        int j = 1;
        do{
            System.out.println(j);  //1 2 3 4 5 6 7 8 9 10
        }while(j <= 10);
    }
}

 

3 改变控制语句顺序

3.1 break

1、break是java语言当中的关键字，被翻译为“中断/折断”
​
2、break + ";" 可以成为一个单独的完整的java语句：break;
​
3、break语句使用在switch语句当中，用来终止switch语句的执行；
​
4、break语句同样可以使用在循环语句当中，用来终止循环的执行。
​
5、break终止哪个循环呢？
​
6、break;语句使用在for,while,do...while循环语句用来跳出循环，终止循环的执行。因为当程序执行到某个条件的时候，后续的循环没必要执行了，再执行也是浪费资源，所以可以终止循环，这样可以提高程序的执行效率。
​
7、以下以for循环为例讲解break;语句。
​
8、默认情况下：break语句终止的是离它最近的循环语句。当然也可以指定终止某个循环，需要给循环起名，采用这种语法：break 循环名称;
​
​
public class BreakTest01
{
    public static void main(String[] args){
​
        for(int i = 0; i < 10; i++){
            if(i == 5){
                break;  //终止的是当前的for循环
            }
            System.out.println(i);  //0 1 2 3 4
        }
        //这里的程序和以上的for循环无关。
        System.out.println("helloworld");
​
        for(int j = 0; j < 3; j++){
            for(int i = 0; i < 10; i++){
                if(i == 5){
                    break;  //终止的是当前的for循环，不会影响到外层的for循环
                }
                System.out.println(i);
            }
        }
​
        //以下语法使用较少
        //给for循环起名for1
        for1:for(int j = 0; j < 3; j++){
            //给for循环起名for2
            for2:for(int i = 0; i < 10; i++){
                if(i == 5){
                    break for1;  //终止for1循环
                }
                System.out.println(i);
            }
        }
    }
}

 

3.2 continue

1、continue表示：继续/go on/下一个
​
2、continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，主要出现循环语句当中用来控制循环的执行。
​
3、break和continue的区别？
    * break表示循环不执行了，跳出循环，终止循环。
    * continue表示终止当前本次循环，直接进入下一次循环  
​
4、continue也有这样的语法：
    continue 循环名称;
    
    
public class ContinueTest01
{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            if(i == 5){
                break;
            }
            System.out.println(i);  //0 1 2 3 4
        }
        System.out.println("helloworld");
​
        for(int i = 0; i < 10; i++){
            if(i == 5){
                continue;  //只要这个语句执行，当前本次循环停止，直接进入下一次循环“继续”执行。
            }
            System.out.println(i);  //0 1 2 3 4 6 7 8 9 
        }
        System.out.println("helloworld");
​
        myFor:for(int i = 0; i < 10; i++){
            if(i == 5){
                continue myFor;  //只要这个语句执行，当前本次循环停止，直接进入下一次循环“继续”执行。
            }
            System.out.println(i);  //0 1 2 3 4 6 7 8 9 
        }
        System.out.println("helloworld");
    }
}

 

3.3 控制语句综合应用

编写for循环找出1~100中所有的素数
​
素数：又被称为质数，能够被1和自身整除，不能被其它数字整除的数字称为素数。
​
升级版：
    编写for循环找出1~100中所有的素数
    要求每8个换一行输出
​
该题目主要掌握的知识点：
    * for循环的使用
    * for循环的嵌套
    * 标记
    * break
    * 统计
        - 整除
        - 归0
        - ...
    
    
public class ForTest09 {
    public static void main(String[] args) {
        /*
        for(int i = 2; i<= 100; i++){  //遍历100以内的自热数
​
            boolean isFlag = true;
​
            for(int j = 2; j< i; j++){//i除以j
                if(i%j == 0){  
                    isFlag = false;
                    break;
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
        }
        */
​
        /*
        for(int i = 2; i <= 10000; i++){
            boolean isFlag = true;
            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    isFlag = false;
                }               
            }
            if(isFlag){
                if()
                System.out.print(i + " ");          
            }
        }
        */
​
        //先编写程序，验证7这个数字是否为素数
        /*
            实现思路：
                7 / 1 【不需要】
                7 / 2 【7 % 2 ！= 0】
                7 / 3 【7 % 3 ！= 0】
                7 / 4 【7 % 4 ！= 0】
                7 / 5 【7 % 5 ！= 0】
                7 / 6 【7 % 6 ！= 0】
                7 / 7 【不需要】
            结论是：7是素数
        */
​
        /*
        int i = 9;
        boolean isFlag = true;  //默认将i看做一个素数
        for(int j = 2; j < i; j++){
            //j是什么：2 3 4 5 6
            if(i % j == 0){
                //非素数
                isFlag = false;
                //已经知道i是非素数，跳出循环，可以提高效率
                break;
            }
        }
        System.out.println(isFlag ? i + "是素数" : i + "不是素数");
        */
​
        /*
        for(int i = 2; i <= 100; i++){
            boolean isFlag = true;  
            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    isFlag = false;
                    break;
                }
            }
            if(isFlag){  //是素数
                System.out.println(i);
            } 
        }
        */
​
​
        //升级版 【加入统计机制】
        /*
        int count = 0;
        for(int i = 2; i <= 100; i++){
            boolean isFlag = true;  
            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    isFlag = false;
                    break;
                }
            }
            if(isFlag){  //是素数                
                System.out.print(i + " ");
                count++;
                if(count % 8 == 0){
                    System.out.println();
                }                
            } 
        } 
        */
​
        int count = 0;
        for(int i = 2; i <= 100; i++){
            boolean isFlag = true;  
            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    isFlag = false;
                    break;
                }
            }
            if(isFlag){  //是素数                
                System.out.print(i + " ");
                count++;
                if(count 8 == 0){
                    System.out.println();
                    //归0
                    count = 0
                }                
            } 
        } 
​
    }
}