03-分支结构

huangyingying20252025-04-02 11:05

分支结构

1. 顺序结构

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

2. 基本if选择结构

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

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

java 复制代码 
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("程序结束");
    }
}
java 复制代码 
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，再退出整个结构，执行后续代码。

java 复制代码 
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("程序结束");
    }
}
java 复制代码 
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，其他均不再执行， 适用(擅长处理)于区间判断。

java 复制代码 
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("程序结束");
    }
}
java 复制代码 
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

java 复制代码 
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之后

java 复制代码 
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穿透效果

java 复制代码 
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写法

java 复制代码 
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("程序结束");

    }
}
java 复制代码 
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各个类型的使用

java 复制代码 
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
存储位置： 基本数据类型存在栈中 引用数据类型名字保存在栈中 值保存在堆中
java 复制代码 
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循环实现的需求为 循环次数确定的情况

java 复制代码 
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循环更为简洁

java 复制代码 
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实现

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

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

java 复制代码 
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循环

java 复制代码 
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循环

java 复制代码 
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 + "遍打印：好好学习");
        }
    }
}
java 复制代码 
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);
    }
}
java 复制代码 
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圈 太累了 退出

java 复制代码 
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门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示录入错误

java 复制代码 
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的当前数

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

java 复制代码 
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关键字：只能用在循环中 表示跳过剩余的循环体 开始一次新的循环

java 复制代码 
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分的学生比例

java 复制代码 
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之间的所有偶数和

java 复制代码 
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调试

相关推荐
ss27311 分钟前
基于Springboot + vue + 爬虫实现的高考志愿智能推荐系统
spring boot·后端·高考
专注API从业者1 小时前
《Go 语言高并发爬虫开发：淘宝商品 API 实时采集与 ETL 数据处理管道》
开发语言·后端·爬虫·golang
Asthenia04121 小时前
Netty writeAndFlush与Pipeline深入分析
后端
欧先生^_^2 小时前
Scala语法基础
开发语言·后端·scala
GetcharZp3 小时前
xterm.js 终端神器到底有多强？用了才知道！
前端·后端·go
洞窝技术3 小时前
MYSQL：关于索引你想知道的
后端·mysql
MrWho不迷糊3 小时前
企业级权限系统怎么设计四 —— ABAC模型统一功能权限与数据权限
后端·微服务
落尘2983 小时前
Spring MVC——传递参数的方式
后端
ITCharge4 小时前
Docker 万字教程：从入门到掌握
后端·docker·容器
落尘2984 小时前
Bean 的作用域和生命周期
后端
热门推荐
01西电B测-计算机网络综合实验(含验收问题)02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07最新 Kubernetes 集群部署 + flannel 网络插件（保姆级教程，最新 K8S 版本）08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09我决定放弃搞 Java 了10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）