03-分支结构

分支结构

1. 顺序结构

概念：程序自顶而下，按照书写顺序执行，这种结构即为顺序结构。

2. 基本if选择结构

语法： if(布尔表达式){ ​ //代码块1 }

后续代码... 执行流程： 对布尔表达式进行判断。 结果为true，则先执行代码块1，再执行后续代码。 结果为false，则跳过代码块1，直接执行后续代码。

package com.xxx.test1;

import java.util.Scanner;

/**
 *  基本if选择结构
 *  需求：根据用户输入的年龄 判断是否成年了
 */
public class TestCommonIf1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的年龄");

        int age = input.nextInt();

        if(age >= 18){
            System.out.println("成年了");
        }


        System.out.println("程序结束");
    }
}

package com.xxx.test1;

import java.util.Scanner;

/**
 *  需求：使用基本if选择结构 根据用户的成绩 进行判断是否可以获得奖励
 *
 *  如果
 *      Java成绩大于90 并且 MySQL成绩大于95
 *  或者
 *      HTML成绩等于100 并且 JavaScript成绩大于80
 *  可以获得奖励
 */
public class TestCommonIf2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入Java成绩");

        double javaScore = input.nextDouble();

        System.out.println("请输入MySQL成绩");

        double mySQLScore = input.nextDouble();

        System.out.println("请输入HTML成绩");

        double htmlScore = input.nextDouble();

        System.out.println("请输入JavaScript成绩");

        double javaScriptScore = input.nextDouble();

        if((javaScore > 90 && mySQLScore > 95) || (htmlScore == 100 && javaScriptScore > 80)){
            System.out.println("可以获得奖励");
        }

        System.out.println("程序结束");
    }
}

3. if-else选择结构

语法： if(布尔表达式){ ​ //代码块1 }else{ ​ //代码块2 } 后续代码... 执行流程： 对布尔表达式进行判断。 结果为true，则先执行代码块1，再退出整个结构，执行后续代码。 结果为false，则先执行代码块2，再退出整个结构，执行后续代码。

package com.xxx.test2;

import java.util.Scanner;

/**
 *  if-else选择结构
 *  需求：根据用户输入的年龄 判断是否成年了  分别给予对应的提示
 *
 *  else结构是不能单独使用的  必须结合 if结构
 *
 *
 *
 */
public class TestCommonIfElse1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的年龄");

        int age = input.nextInt();

        if(age >= 18) {
            System.out.println("成年了");
        } else {
            System.out.println("未成年");
        }


        System.out.println("程序结束");
    }
}

package com.xxx.test2;

import java.util.Scanner;

/**
 *  需求：if-else选择结构 根据用户的成绩 进行判断是否可以获得奖励  分别给予对应的提示
 *
 *  如果
 *      Java成绩大于90 并且 MySQL成绩大于95
 *  或者
 *      HTML成绩等于100 并且 JavaScript成绩大于80
 *  可以获得奖励
 */
public class TestCommonIfElse2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入Java成绩");

        double javaScore = input.nextDouble();

        System.out.println("请输入MySQL成绩");

        double mySQLScore = input.nextDouble();

        System.out.println("请输入HTML成绩");

        double htmlScore = input.nextDouble();

        System.out.println("请输入JavaScript成绩");

        double javaScriptScore = input.nextDouble();

        if((javaScore > 90 && mySQLScore > 95) || (htmlScore == 100 && javaScriptScore > 80)){
            System.out.println("可以获得奖励");
        }else{
            System.out.println("继续加油~");
        }

        System.out.println("程序结束");
    }
}

4. 多重if选择结构

多重if结构中 最后的else结构不是必须的 是可选的 根据需求是否书写

如果书写了else结构 那么最终的结果属于 多选1

如果不书写else结构 那么结果 有可能 多选0 或者 多选1

多重if中的else -if 是没有个数限制的 根据需求书写
语法： if(布尔表达式1){ ​ //代码块1 }else if(布尔表达式2){ ​ //代码块2 }else if(布尔表达式3){ ​ //代码块3 }else{ ​ //代码块4 }
执行流程： 表达式1为true，则执行代码块1，再退出整个结构。

表达式2为true，则执行代码块2，再退出整个结构。

表达式3为true，则执行代码块3，再退出整个结构。

以上均为false，则执行代码块4，再退出整个结构。

注意：相互排斥，有一个为true，其他均不再执行， 适用(擅长处理)于区间判断。

package com.xxx.test3;

import java.util.Scanner;

/**
 *  根据用户输入的名次进行对应的奖励
 *
 *  第一名 奖励欧洲一日游
 *  第二名 奖励苹果16袋
 *  第三名 奖励笔记本一本
 *  第四名 奖励口头表扬一次
 *  其他名次 继续加油~
 *
 *  当前使用多重if处理的是 条件为固定的具体的 等值 情况  条件编写顺序没有要求
 *  但是 推荐书写为有序的 这样代码可读性更强
 *
 */
public class TestManyIf1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的名次");

        int num = input.nextInt();

        if(num == 2){
            System.out.println("奖励苹果16袋");
        }else if (num == 1){
            System.out.println("奖励欧洲一日游");
        }else if(num == 4){
            System.out.println("奖励口头表扬一次");
        }else if(num == 3){
            System.out.println("奖励笔记本一本");
        }else{
            System.out.println("继续加油~");
        }

        System.out.println("程序结束");
    }
}

package com.xxx.test3;

import java.util.Scanner;

/**
 *  使用多重if根据用户输入的成绩 划分等级
 *  大于90分 优秀
 *  大于80分 良好
 *  大于70分 中等
 *  大于等于60 及格
 *  其他 不及格
 *
 *  当前案例使用多重if处理 条件为 连续区间的情况  条件必须为有序的 升序或者降序 都可以
 *  不能是乱序的 否则 结果错误
 */
public class TestManyIf2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的成绩");

        int score = input.nextInt();

        if(score > 80){
            System.out.println("良好");
        }else if(score > 90){
            System.out.println("优秀");
        }else if(score > 60){
            System.out.println("及格");
        }else if (score >= 70){
            System.out.println("中等");
        }else{
            System.out.println("不及格");
        }

        System.out.println("程序结束");

    }
}

5. 嵌套if选择结构

语法： if(外层表达式){ ​ if(内层表达式){ ​ //内层代码块1 ​ }else{ ​ //内层代码块2 ​ } }else{ ​ //外层代码块 }
执行流程： 当外层条件满足时，再判断内层条件。

注意： 一个选择结构中，可嵌套另一个选择结构。 嵌套格式正确的情况下，支持任意组合。
对应字符串内容的判断 不要使用== 或者 !=

应该使用equals方法

String类型变量名.equals("比较的内容") 内容相同结果为true 否则结果为false

package com.xxx.test4;

import java.util.Scanner;

/**
 *  嵌套if
 *  需求：百米跑步比赛 跑步时间小于15秒 可以进入决赛
 *  根据用户的跑步时间 判断是否可以进入决赛 再根据性别 进行分组 进入男子组 或者 女子组
 *
 */
public class TestInnerIf {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的跑步时间");

        double time = input.nextDouble();



        if(time < 15){

            System.out.println("请输入您的性别");

            String sex = input.next();


            // 可以进入决赛
            // 对应字符串内容的判断 不要使用== 或者 !=
            // 应该使用equals方法
            // String类型变量名.equals("比较的内容")  内容相同结果为true  否则结果为false
            if(sex.equals("男")){
                System.out.println("恭喜你，进入男子组");
            }else if(sex.equals("女")){
                System.out.println("恭喜你，进入女子组");
            }else{
                System.out.println("性别错误");
            }
        }else{
            // 淘汰
            System.out.println("下次继续加油~");
        }

        System.out.println("程序结束");
    }
}

6. 选择结构注意问题

if语句块只有一条执行语句时，一对{}可以省略，但建议保留

当多重if结构是"多选一"时，最后的else是可选的，根据需要可以省略

当多重if结构多个条件是"互斥"关系时，条件判断语句及执行语句间顺序无所谓

当多个条件是"连续的区间"时，条件必须为升序或者降序

7. switch结构

语法： switch(变量|表达式){ ​ case 值1: ​ 逻辑代码1; ​ case 值2: ​ 逻辑代码2; ​ case 值n: ​ 逻辑代码n; ​ default: ​ 未满足时的逻辑代码; }
可判断的类型： byte、short、int、char、String（JDK7+） 枚举

执行流程： 如果变量中的值等于值1，则执行逻辑代码1。 如果变量中的值等于值2，则执行逻辑代码2。 如果变量中的值等于值n，则执行逻辑代码n。 如果变量中的值没有匹配的case值时，执行default中的逻辑代码。

注意：所有case的取值不可相同。
case穿透：默认情况下 执行完前边的case 会顺势继续向下执行 这种现象称之为 case穿透

如果需要每个case都是独立的 可以使用break 跳出/中断/结束 switch结构

default在switch结构中 不是必须的 是可选的 根据需求是否书写

并且位置不是固定的 可以书写在任何位置 推荐书写在所有case之后

package com.xxx.test5;

import java.util.Scanner;

/**
 *
 *  使用switch结构实现如下需求：
 *  第一名 奖励欧洲一日游
 *  第二名 奖励苹果16袋
 *  第三名 奖励笔记本一本
 *  第四名 奖励口头表扬一次
 *  其他名次 继续加油~
 *
 *  switch支持的数据类型：byte short int char String(JDK7) 枚举
 *
 *  case穿透：默认情况下 执行完前边的case 会顺势继续向下执行 这种现象称之为 case穿透
 *  如果需要每个case都是独立的 可以使用break   跳出/中断/结束  switch结构
 *
 *  default在switch结构中 不是必须的 是可选的  根据需求是否书写
 *  并且位置不是固定的 可以书写在任何位置 推荐书写在所有case之后
 */
public class TestSwitch1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的名次");

        int number = input.nextInt();

        switch(number){
            case 1:
                System.out.println("奖励欧洲一日游");
                break;
            case 2:
                System.out.println("奖励苹果16袋");
                break;
            case 3:
                System.out.println("奖励笔记本一本");
                break;
            case 4:
                System.out.println("奖励口头表扬一次");
                break;
            default:
                System.out.println("继续加油~");
                break;
        }

        System.out.println("程序结束");

    }
}

合理利用case穿透效果

package com.xxx.test5;

import java.util.Scanner;

/**
 *  合理利用case穿透效果
 *  使用switch结构实现如下需求：
 *  第一名 奖励欧洲一日游
 *  第二名 奖励欧洲一日游
 *  第三名 奖励笔记本一本
 *  第四名 奖励笔记本一本
 *  其他名次 继续加油~
 *
 */
public class TestSwitch2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的名次");

        int number = input.nextInt();

        switch(number){
            case 1:
            case 2:
                System.out.println("奖励欧洲一日游");
                break;
            case 3:
            case 4:
                System.out.println("奖励笔记本一本");
                break;
            default:
                System.out.println("继续加油~");
                break;
        }

        System.out.println("程序结束");

    }
}

JDK14新增的switch写法

package com.xxx.test5;

import java.util.Scanner;

/**
 *
 *  使用switch结构实现如下需求：
 *  第一名 奖励欧洲一日游
 *  第二名 奖励欧洲一日游
 *  第三名 奖励笔记本一本
 *  第四名 奖励笔记本一本
 *  其他名次 继续加油~
 *
 */
public class TestSwitch3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入您的名次");

        int number = input.nextInt();
        switch(number){
            case 1->
                System.out.println("奖励欧洲一日游");
            case 2->
                System.out.println("奖励苹果16袋");
            case 3->
                System.out.println("奖励笔记本一本");
            case 4->
                System.out.println("奖励口头表扬一次");
            default->
                System.out.println("继续加油~");
        }

        System.out.println("程序结束");

    }
}

package com.xxx.test5;

import java.util.Scanner;

/**
 *  alt + 回车 万能提示键
 *
 *  JDK14对switch结构语法做了优化
 *  使用 -> 的格式 可以省略 break关键字
 *  注意 如果使用了 -> 则不能书写break  因为自带break效果
 */
public class TestSwitch4 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入月份（1-12）：");
        int month = input.nextInt();

        String season;
        switch (month) {
            case 1,2,12-> season = "冬季";
            case 3,4,5-> season = "春季";
            case 6,7,8-> season = "夏季";
            case 9,10,11-> season = "秋季";
            default-> season = "无效的月份";
        }

        System.out.println("该月份属于：" + season);
    }


}

switch各个类型的使用

package com.xxx.test5;

/**
 * switch各个类型的使用
 *
 * char类型有三种赋值方式 所以在switch结构中 case后边也支持三种写法
 *
 * 枚举 ：后续学习
 */
public class TestSwitch5 {
    public static void main(String[] args) {
        byte b1 = 1;
        short s1 = 2;
        int i1 = 3;
        char c1 = 'A';
        String str1 = "A";


        switch (str1) {
            case "A":
                System.out.println("取值为1");
                break;
            case "66":
                System.out.println("取值为2");
                break;
            case "\u4e2d":
                System.out.println("取值为3");
                break;
            case "4":
                System.out.println("取值为4");
                break;
            default:
                System.out.println("其他取值");
        }

        System.out.println("程序结束");

    }
}

8. 局部变量(LocalVariable)

局部变量	描述
定义位置：	定义在方法体内
作用范围：	离当前变量最近的大括号以内
默认值：	没有默认值 必须先赋值才能使用
重名问题：	重合的作用范围以内 不能重名 (不重合的范围 可以重名)
生命周期：	随着方法的入栈(stack 开始执行)而生效 随着方法的出栈/弹栈 (stack 方法结束)而死亡 FILO First In Last Out
存储位置：	基本数据类型存在栈中 引用数据类型名字保存在栈中 值保存在堆中

package com.xxx.test6;

/**
 *  局部变量
 *      定义位置：定义在方法体内
 *      作用范围：离当前变量最近的大括号以内
 *      默认值：没有默认值 必须先赋值才能使用
 *      重名问题：重合的作用范围以内 不能重名 (不重合的范围 可以重名)
 *
 *      生命周期：随着方法的入栈(stack 开始执行)而生效 随着方法的出栈/弹栈  (stack 方法结束)而死亡  FILO  First In Last Out
 *      存储位置：基本数据类型存在栈中 引用数据类型名字保存在栈中 值保存在堆中
 */
public class TestLocalVariable {
    public static void main(String[] args) {
        int a = 100;
        int b;


        System.out.println(a);

        if(a > 100){
            int c = 100;
            a = 200;
            System.out.println(a);
        }else{
            int c = 200;
            System.out.println(c);
            System.out.println(a);
        }

    }
}

循环结构

1.while循环

计数器初始化;

while ( 循环条件 ) { ​ ​ 循环操作

​ 计数器变化

}
任何循环都有四个必不可少的部分

1.计数器初始化 2.循环条件 3.循环体 4.计数器变化

使用while循环实现打印100遍好好学习

当前使用while循环实现的需求为 循环次数确定的情况

package com.xxx.test7;

/**
 *  任何循环都有四个必不可少的部分
 *      1.计数器初始化 2.循环条件  3.循环体 4.计数器变化
 *
 *  使用while循环实现打印100遍好好学习
 *
 *  当前使用while循环实现的需求为 循环次数确定的情况
 *
 *
 */
public class TestWhile1 {
    public static void main(String[] args) {
        int i = 1; // 计数器初始化
        while(i <= 10000){ // 循环条件
            System.out.println("第" + i + "遍打印：好好学习，天天向上"); // 循环体
            i++; // 计数器变化
        }

        System.out.println(i);

        System.out.println("程序结束");


    }
}

需求：老师每天检查赵四的学习任务是否合格，如果不合格，则继续进行。

老师给赵四安排的每天的学习任务为：上午阅读教材，学习理论部分，下午上机编程，掌握代码部分。

当前案例使用while循环实现的位 循环次数不确定的情况

通常使用while循环处理循环次数不确定的情况 因为循环次数确定 for循环更为简洁

package com.xxx.test7;

import java.util.Scanner;

/**
 *  需求：老师每天检查赵四的学习任务是否合格，如果不合格，则继续进行。
 *  老师给赵四安排的每天的学习任务为：上午阅读教材，学习理论部分，下午上机编程，掌握代码部分。
 *
 *  当前案例使用while循环实现的位 循环次数不确定的情况
 *  通常使用while循环处理循环次数不确定的情况 因为循环次数确定 for循环更为简洁
 *
 */
public class TestWhile2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入今天的学习任务是否合格？y/n");

        String answer = input.next(); // 计数器初始化

        while(answer.equals("n")){ // 循环条件

            // 循环体
            System.out.println("上午阅读教材，学习理论部分");
            System.out.println("下午上机编程，掌握代码部分");

            // 计数器变化
            System.out.println("请输入今天的学习任务是否合格？y/n");
            answer = input.next();
        }

        System.out.println("程序结束");
    }
}

2. do-while循环

计数器初始化;

do {

循环操作

}while ( 循环条件 );
使用do-while实现

经过几天的学习，老师给赵四一道测试题，让他先上机编写程序完成，

然后老师再检查是否合格。如果不合格，则继续编写......

package com.xxx.test8;

import java.util.Scanner;

/**
 *  使用do-while实现
 * 经过几天的学习，老师给赵四一道测试题，让他先上机编写程序完成，
 * 然后老师再检查是否合格。如果不合格，则继续编写......
 */
public class TestDoWhile1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        String answer; // 计数器初始化

        do{

            // 循环体
            System.out.println("上机编写代码测试......");

            System.out.println("请输入你的成绩是否合格？y/n");

            answer = input.next(); // 计数器变化

        } while(answer.equals("n")); // 循环条件


        System.out.println("恭喜你完成学习任务");

        System.out.println("程序结束");


    }
}

使用do-while实现打印100遍好好学习

总结：do-while循环也可以用于实现循环次数确定和不确定的情况 通常用于处理循环次数确定的情况

因为循环次数确定的情况 推荐使用for循环

package com.xxx.test8;

/**
 *  使用do-while实现打印100遍好好学习
 *
 *  总结：do-while循环也可以用于实现循环次数确定和不确定的情况 通常用于处理循环次数确定的情况
 *  因为循环次数确定的情况 推荐使用for循环
 */
public class TestDoWhile2 {
    public static void main(String[] args) {
        int i = 1;
        do{
            System.out.println("打印第" + i + "遍：好好学习");
            i++;
        }while(i <= 100);

        System.out.println("程序结束");
    }
}

3. for循环

package com.xxx.test9;

/**
 *  使用for循环打印100遍好好学习
 *  注意for循环的执行顺序
 */
public class TestFor1 {
    public static void main(String[] args) {
        for(int i = 1;i <= 10000;i++){
            System.out.println("第" + i + "遍打印：好好学习");
        }
    }
}

package com.xxx.test9;

import java.util.Scanner;

/**
 *  循环输入某同学结业考试的5门课成绩，并计算平均分
 */
public class TestFor2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入你的名字");

        String name = input.next();

        double sum = 0;

        for(int i = 1;i <= 5;i++){
            System.out.println("请输入第" + i + "门成绩");

            double score = input.nextDouble();

            sum += score; // 累计分数
        }


        System.out.println(name + "同学的总分为：" + sum);
        System.out.println(name + "同学的平均分为：" + sum / 5);
    }
}

package com.xxx.test9;

import java.util.Scanner;

/**
 *  根据用户输入的整数打印加法表
 */
public class TestFor3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入一个整数 ");

        int number = input.nextInt();

        // 递减效果：使用一个固定的值 减去一个递增的值 即可

        for(int i = 0; i <= number;i++){
            System.out.println(i  + "+"  +  (number - i)  + "="  + number);
        }
    }
}

4. 三种循环对比

区别1：语法 ​ 区别2：执行顺序 ​ while 循环：先判断，再执行 ​ do-while循环：先执行，再判断 ​ for循环：先判断，再执行

区别3：适用情况 ​ 循环次数确定的情况，通常选用for循环 ​ 循环次数不确定的情况，通常选用while或do-while循环

5. break关键字

break关键字：可以用于switch结构 或者 循环结构 分别表示 中断switch结构 或者 循环结构

break在循环中 通常结合 分支语句一起使用
需求：使用循环描述跑步10圈 当跑完第8圈 太累了 退出

package com.xxx.test11;

/**
 *  break关键字：可以用于switch结构 或者 循环结构 分别表示 中断switch结构 或者 循环结构
 *
 *  break在循环中 通常结合 分支语句一起使用
 *
 *  需求：使用循环描述跑步10圈 当跑完第8圈 太累了 退出
 */
public class TestBreak1 {
    public static void main(String[] args) {
        for(int i = 1;i <= 10;i++){
            System.out.println("跑步第" + i + "圈");
            if(i == 8){
                System.out.println("太累了，退出");
                break;
            }
        }


        System.out.println("程序结束");

    }
}

循环录入某学生5门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示录入错误

package com.xxx.test11;

import java.util.Scanner;

/**
 *  循环录入某学生5门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示录入错误
 */
public class TestBreak2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int sum = 0;// 用于累计总分

        boolean flag = true;

        for(int i = 1;i <= 5;i++){
            System.out.println("请输入第" + i + "门成绩");

            int score = input.nextInt();

            if(score < 0){
                flag = false;
                System.out.println("分数录入错误，停止录入");
                break;
            }

            sum += score;
        }


        if(flag){ // 对于布尔类型的变量 或者 表达式  作为判断 直接书写 就等同于 省略了 ==true
            System.out.println("总分为：" + sum);
            System.out.println("平均分为：" + sum / 5);
        }else{
            System.out.println("分数录入错误，不再计算平均分");
        }

    }
}

1~10之间的整数相加，得到累加值大于20的当前数

使用其他两种循环 实现这个需求

package com.xxx.test11;

/**
 *  1~10之间的整数相加，得到累加值大于20的当前数
 *
 *  使用其他两种循环 实现这个需求
 *
 */
public class TestBreak3 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1;i <= 10;i++){
            sum += i;
            if(sum > 20){
                System.out.println(i);
                break;
            }
        }
        System.out.println(sum);
    }
}

6. continue关键字

continue关键字：只能用在循环中 表示跳过剩余的循环体 开始一次新的循环

package com.xxx.test12;

/**
 *  continue关键字：只能用在循环中 表示跳过剩余的循环体 开始一次新的循环
 *
 *  shift + alt + ↑↓  移动当前行代码
 *
 */
public class TestContinue1 {

    public static void main(String[] args) {
        for(int i = 1;i <= 10;i++){
            if(i == 5){
                break;
            }
            System.out.print(i + "\t");
        }

        System.out.println();

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

        for(int i = 1;i <= 10;i++){
            if(i == 5){
                continue;
            }
            System.out.print(i + "\t");
        }
    }
}

循环录入Java课的学生成绩，统计分数大于等于80分的学生比例

package com.xxx.test12;

import java.util.Scanner;

/**
 *  循环录入Java课的学生成绩，统计分数大于等于80分的学生比例
 */
public class TestContinue2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入学生人数");

        int number = input.nextInt(); // 总人数

        double count = 0;// 用于统计大于80分的人数

        for(int i = 1;i <= number;i++ ){

            System.out.println("请输入成绩");

            int score = input.nextInt();

            if(score < 80){ // 如果成绩小于80  则表示不符合统计的要求
                continue; // continue表示跳过剩余的循环体 开始一次新的循环
            }
            count++;
        }

        System.out.println("大于等于80分的学生占比为：" + count / number * 100 + "%");

    }
}

求1~10之间的所有偶数和

package com.xxx.test12;

/**
 * 求1~10之间的所有偶数和
 *
 * 使用其他两种循环 实现
 *
 */
public class TestContinue3 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1;i <= 10;i++){
            if(i % 2 != 0){
                continue;
            }
            sum += i;
        }

        System.out.println(sum);
    }
}

7. break和continue的区别？

使用场合 ​ break用于switch结构和循环结构中 ​ continue用于循环结构中

作用（循环结构中） ​ break语句终止某个循环，程序跳转到循环块外的下一条语句 ​ continue跳出本次循环，进入下一次循环 ​ 双重循环亦如此

8. debug调试