day04 switch语句和循环语句

最新推荐文章于 2025-03-30 19:12:53 发布
最新推荐文章于 2025-03-30 19:12:53 发布
阅读量1.1k 收藏 26
点赞数 19
分类专栏： JavaSE 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010297404/article/details/145944589
版权

文章目录

day04 switch和循环

  • switch

  • 理解for语句的格式和执行流程

  • 随机数公式

  • 理解while语句的格式和执行流程

  • 了解do…while语句的格式和执行流程

  • 了解跳出语句break，continue的意义

  • 理解死循环的执行流程

  • 理解循环嵌套的执行流程

4.1 分支结构：switch选择结构

4.1.1基本语法

  1. 语法格式：

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

  2. 执行过程：

    1685608499265

    • （1）入口

      • ①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；

      • ②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里

    • （2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿

    • （3）出口

      • ①自然出口：遇到了switch的结束}

      • ②中断出口：遇到了break等

    注意：

    （1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）

    （2）case后面必须是常量值，而且不能重复

  3. 语法案例演示1：

    public class SwitchDemo01 {
	public static void main(String[] args) {
		//定义指定的星期
		int weekday = 5;
		
		//switch语句实现选择
		switch(weekday) {
            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("你的数字有误");
                break;
		}
	}
}

  4. 语法案例演示2：case的穿透性

    在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，switch语句执行终止。

练习：根据指定的月份输出对应季节（switch语句）

/*
 * 需求：指定一个月份，输出该月份对应的季节。
 * 		一年有四季
 * 		3,4,5	春季
 * 		6,7,8	夏季
 * 		9,10,11	秋季
 * 		12,1,2	冬季
 * 
 * 分析：
 * 		A:指定一个月份
 * 		B:判断该月份是几月,根据月份输出对应的季节
 * 			if
 * 			switch
 */
public class SwitchTest02 {
	public static void main(String[] args) {
		//指定一个月份
		int month = 5;
		
		/*
		switch(month) {
            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;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            default:
                System.out.println("你输入的月份有误");
                break;
		}
		*/
	
        // 改进版 
		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("你输入的月份有误");
                break;
		}
	}
}

  1. 常见错误实现1：

    switch(month){
    case 3|4|5://3|4|5 用了位运算符，11 | 100 | 101结果是 111是7
        System.out.println("春季");
        break;
    case 6|7|8://6|7|8用了位运算符，110 | 111 | 1000结果是1111是15
        System.out.println("夏季");
        break;
    case 9|10|11://9|10|11用了位运算符，1001 | 1010 | 1011结果是1011是11
        System.out.println("秋季");
        break;
    case 12|1|2://12|1|2 用了位运算符，1100 | 1 | 10 结果是1111，是15
        System.out.println("冬季");
        break;
    default:
        System.out.println("输入有误");
}

4.1.2 if语句与switch语句比较

  • if语句的条件是一个布尔类型值，通常根据某个判断结果进入分支，使用范围更广。

  • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），一般条件是几个固定的常量值时使用switch语句。

  • 如果根据进入分支的条件是几个固定的常量值，这时使用if和switch都可以，如果条件选项比较多时，适合使用switch语句（效率高）。

        if是逐行判断
    switch因为case后面是不变的常量 不会逐个判断直接定位相等的值

比如：当条件是x>0时，进入某分支执行代码，这时适合使用if语句，不适合使用switch语句。

4.2. 循环语句(重点+难点)

4.2.1为什么需要循环?

顺序和分支结构的程序语句只能被执行一次。
如果想要同样的操作执行多次，比如重复输出100次HelloWorld 就需要使用循环结构。
    
循环:满足条件反复执行的结构

Java中有三种主要的循环结构：

  • for 循环
  • while 循环
  • do…while 循环

4.2.2 for循环

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要通过修改循环变量使得循环判断条件为false，从而结束循环，否则循环将一直执行下去，形成死循环。

  1. for循环语句格式：

    for(初始化语句①; 循环条件语句②; 迭代控制语句④){
		循环体语句③
}

for(;;){
    循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}

    注意：

    （1）for(;;)中的两个；是不能多也不能少

    （2）循环条件必须是boolean类型

    （3）如果循环条件语句②省略的话，就默认为循环条件成立

  2. 执行流程：

    • 第一步：执行初始化语句①，完成循环变量的初始化；

    • 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

      • 如果是true，执行第三步③；

      • 如果是false，循环语句中止，循环不再执行。

    • 第三步：执行循环体语句③

    • 第四步：执行迭代控制语句④，针对循环变量重新赋值

    • 第五步：根据循环变量的新值，重新从第二步②开始再执行一遍

    • 1685608528980

  3. 语法演示案例1：

    打印10次的HelloWorld

    public class ForDemo01 {
	public static void main(String[] args) {
    //控制台输出10次HelloWorld，不使用循环
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("-------------------------");

		//用循环改进，循环10次
		//定义变量从10开始，循环条件为<=10
		for(int x = 1; x <= 10; x++) {
			System.out.println("HelloWorld"+x);
		}
	}
}

  4. 语法演示案例2：

    打印1-5和5-1

    /*
 * 练习：利用for语句打印1-5和5-1
 */
public class ForTest01 {
	public static void main(String[] args) {
		//原始做法
		System.out.println(1);
		System.out.println(2);
		System.out.println(3);
		System.out.println(4);
		System.out.println(5);
		System.out.println("===============");
		
		//用循环改进
		for(int x=1; x<=5; x++) {
			System.out.println(x);
		}
		System.out.println("===============");
		
		//1-5的数据我们获取到了，如何获取5-1呢?
		for(int x=5; x>=1; x--){
			System.out.println(x);
		}
	}
}

  5. 语法演示案例3：

    求出1-100之间数据之和

    /*
 * 练习：求出1-5之间数据之和
 * 
 * 分析：
 * 		1.定义求和变量，初始化值是0
 * 		2.获取1-5之间的数据，用for循环实现
 * 		3.把每一次获取到的数据，累加起来就可以了
 * 		4.输出求和变量即可
 */
public class ForTest02 {
	public static void main(String[] args) {
		//定义求和变量，初始化值是0
		int sum = 0;
		
		//获取1-5之间的数据，用for循环实现
		for(int x=1; x<=100; x++) {
			//把每一次获取到的数据，累加起来就可以了
			//sum = sum + x;
			/*
			 * 第一次：sum = 0 + 1 = 1
			 * 第二次：sum = 1 + 2 = 3
			 * 第三次：sum = 3 + 3 = 6
			 * 第四次：sum = 6 + 4 = 10
			 * 第五次：sum = 10 + 5 = 15
			 .。。
			 */
			sum += x;
		}
		
		//输出求和结果
		System.out.println("sum:" + sum);
	}
}

1685764372785

  1. 语法演示案例4：

求出1-100之间偶数和

/*
 * 练习：求出1-100之间偶数和
 * 
 * 分析：
 * 		1.定义求和变量，初始化值是0
 * 		2.获取1-100之间的数据，用for循环实现
 * 		3.把获取到的数据进行判断，看是否是偶数
 * 			如果是，就累加
 * 		4.输出求和结果
 */
public class ForTest03 {
	public static void main(String[] args) {
		//定义求和变量，初始化值是0
		int sum = 0;
		
		//获取1-100之间的数据，用for循环实现
		for(int x=1; x<=100; x++) {
			//把获取到的数据进行判断，看是否是偶数
			if(x % 2 == 0) {
				sum += x;
			}
		}
		
		//输出求和结果
		System.out.println("sum:"+sum);
	}
}
注意事项
- 判断条件语句无论简单还是复杂，结果是boolean类型。
- 循环体语句如果是一条语句，大括号可以省略；
	如果是多条语句，大括号不能省略。建议永远不要省略。
- 一般来说：有左大括号就没有分号，有分号就没有左大括号

4.2.3 while循环

  1. while循环语句标准格式：

    while (循环条件语句①) {
    循环体语句②；
}
while(true){
     循环体语句;//如果此时循环体中没有跳出循环的语句，也是死循环
}

    注意：

    while(循环条件)中循环条件必须是boolean类型

    执行流程：

    • 第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；
      • 如果是true，执行第二步；
      • 如果是false，循环语句中止，循环不再执行。
    • 第二步：执行循环体语句②；
    • 第三步：循环体语句执行完后，重新从第一步开始再执行一遍

    1685608552452

  2. while循环语句扩展格式：

    初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}

    执行流程：

    • 第一步：执行初始化语句①，完成循环变量的初始化；
    • 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
      • 如果是true，执行第三步；
      • 如果是false，循环语句中止，循环不再执行。
    • 第三步：执行循环体语句③
    • 第四步：执行迭代语句④，针对循环变量重新赋值
    • 第五步：根据循环变量的新值，重新从第二步开始再执行一遍

  3. 语法演示案例1：

    遍历1-100之间的偶数

    int num = 2;
while(num<=100){
    System.out.println(num);
    num+=2;
}

  4. 语法演示案例2：

    趣味折纸

    /*
 *	练习：趣味折纸
 * 	
 *	题目：
 *		一张A4纸厚度是1毫米,珠穆朗玛峰的高度8848米,
 		请问:将纸对折多少次可以达到珠穆朗玛峰的高度?
 */
public class WhileTest01 {
    public static void main(String[] args) {
		int zH = 1;//单位是毫米
		int sH = 8848 * 100 * 10;
		int count = 0;


		//循环代表的是不断的对折
		while(zH < sH){
			//对折
			//zH = zH * 2;
			zH *= 2;
			count++;
		}

		System.out.println(count);
    }
}

4.2.4 do…while循环

  1. do…while循环语句格式：

    初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；

    注意：

    （1）while(循环条件)中循环条件必须是boolean类型

    （2）do{}while();最后有一个分号

    （3）do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

    执行流程：

    • 第一步：执行初始化语句①，完成循环变量的初始化；
    • 第二步：执行循环体语句②；
    • 第三步：执行迭代语句③，针对循环变量重新赋值；
    • 第四步：执行循环条件语句④，看循环条件语句的值是true，还是false；
      • 如果是true，根据循环变量的新值，重新从第二步开始再执行一遍；
      • 如果是false，循环语句中止，循环不再执行。

    1685608577159

  2. 练习：猜数

    随机生成一个1-100的数，猜数字游戏

    从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次

    提示：随机数 Math.random()

    double num = Math.random();// [0,1)的小数

    package com.atguigu.test;


import java.util.Scanner;

public class Demo {

 public static void main(String[] args) {

 //随机生成一个100以内的整数
    /*
		Math.random() ==> [0,1)的小数
		Math.random()* 100 ==> [0,100)的小数
		Math.random()* 100 + 1 ==> [1,101)的小数
		(int)(Math.random()* 100 + 1) ==> [1,101)的整数
		*/
     int num = (int)(Math.random()* 100 + 1);
     System.out.println(num);

     //声明一个变量，用来存储猜的次数
     int count = 0;

     Scanner input = new Scanner(System.in);
     int guess;//提升作用域
     do{
         System.out.print("请输入1-100的整数：");
         guess = input.nextInt();

         //输入一次，就表示猜了一次
         count++;

         if(guess > num){
             System.out.println("大了");
         }else if(guess < num){
             System.out.println("小了");
         }
     }while(num != guess);

     System.out.println("一共猜了：" + count+"次");


 }

}

4.2.5 循环语句的区别

  1. 从循环次数角度分析

  • do…while循环至少执行一次循环体语句

  • for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句

  1. 从循环变量的生命周期角度分析

  • for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；

  • while和do…while循环的循环变量因为在外面声明的，所以while和do…while结束后可以被继续使用的；

  1. 如何选择

    • 遍历有明显的循环次数（范围）的需求，选择for循环

    • 遍历没有明显的循环次数（范围）的需求，循环while循环

    • 如果循环体语句块至少执行一次，可以考虑使用do…while循环

    • 本质上：三种循环之间是可以互相转换的，都能实现循环的功能

  2. 三种循环结构都具有四要素：

  • （1）循环变量的初始化表达式

  • （2）循环条件

  • （3）循环变量的修改的迭代表达式

  • （4）循环体语句块

  1. 死循环比较

  • ​ for(;😉{循环体} ，除循环体外不需要执行其他语句，性能略高

  • ​ while(true){ 循环体}，除循环体外还需要执行小括号里的表达式

4.2.6 关键字：break

退出 ,结束

  1. 使用场景：终止switch或者当前循环

    • 在选择结构switch语句中
    • 在循环语句中
    • 离开使用场景的存在是没有意义的
  2. 案例演示1
    class Demo1_Break {
	public static void main(String[] args) {
		for (int x = 1;x <= 10 ;x++ ) {
			if (x == 4) {
				break;		//结束循环
			}
			System.out.println("x = " + x);
		}
	}
}

  3. 语法案例演示2：break同时存在switch和循环中

    ATM功能演示

    界面效果：

    =========ATM=======
	1、存款
	2、取款
	3、显示余额
	4、退出
请选择：

    代码示例：

    package com.atguigu.test;


import java.util.Scanner;

public class Demo {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        //声明一个变量表示余额
        double balance = 0.0;
        while (true) {
            System.out.println("=========ATM=======");
            System.out.println("\t1、存款");
            System.out.println("\t2、取款");
            System.out.println("\t3、显示余额");
            System.out.println("\t4、退出");
            System.out.print("请选择：");
            int select = input.nextInt();

            switch (select) {
                case 1:
                    System.out.print("存款的金额：");
                    double money = input.nextDouble();
                    balance += money;
                    System.out.println("存款后的余额：" + balance);
                    break;
                case 2:
                    System.out.print("取款的金额：");
                    money = input.nextDouble();

                    if(balance >= money){
                        balance -= money;
                        System.out.println("取款后的余额：" + balance);
                    }else{
                        System.out.println("现在的余额：" + balance + ",取款金额大于余额,取款失败");
                    }
                    break;
                case 3:
                    System.out.println("现在的余额：" + balance);
                    break;
                case 4:
                    flag = false;
                    break;//只能结束switch
                default:
                    System.out.println("无效指令");
                    break;
            }
        }

    }
}

4.2.7 关键字：continue

  • 使用场景：结束本次循环，继续下一次的循环

    //遍历打印1-10的整数，但不打印3的倍数
public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
        //需求:不打印3的倍数
        if(i % 3 == 0){
            continue;
        }
        System.out.println(i);
    }
}

  • 练习：打印1-100之间的整数，跳过7的倍数和7结尾的数

    public static void main(String[] args){
    //打印1-100之间的整数，跳过7的倍数和7结尾的数
    for(int i=1; i<=100; i++){
        if(i%7==0 || i%10==7){
            continue;
            //break;
        }
        System.out.println(i);
    }
}
流程控制语句：分支结构
weixin_44544716的博客
05-25 846
开发工具与关键技术：Java、myEclipse 作者：吴晓佩 撰写时间：2019年5月20日 流程控制分为三种基本结构：顺序结构、分支结构和循环结构。如下简述的是流程控制语句中的分支结构。分支结构是一种选择结构，根据条件的值选择不同的执行流程，可以得到不同的结果。分支结构包括单分支语句（if-else语句）和多分支语句（switch语句）。 1、 if-else语句：if…else 语句可以看作...
Day04 Java 从键盘录入数据及流程控制语句if，switch语句，for，while循环等
m0_64350718的博客
01-06 1188
从键盘输入需要三个步骤： 1、导包：import java.until.Scanner; 2、创建：
基本语法—流程控制语句
weixin_45149712的博客
12-04 339
基础语法–流程控制语句 1 顺序结构 任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。 public static void main(String[] args){ //顺序执行，根据编写的顺序，从上到下运行 System.out.println(1); System.out.println(2);
流程控制语句结构
baidu_39300522的博客
09-28 386
1.顺序结构： 从上往下执行，上一句执行完才轮到下一句，逐条执行 2.分支结构：只执行其中的一个分支，看条件执行 if-else switch-case 3.循环结构：重复执行某些语句 while(){} do{}while() for(;
Switch语句的用法（包含例题）
最新发布
study_24_4_3的博客
03-30 488
Switch语句其实是一种特殊的if else结构，适用于判断条件存在多个结果的情况。它把多重else if改为更清晰 可读性更好的形式。
流程控制语句
JavaJackmake的博客
05-08 128
流程控制语句 流程控制语句： 1、顺序结构：从上往下执行 2、选择结构：满足不同的条件执行不同的语句 1)、单分支|单选择 if(条件表达式){ 语句体; } 执行流程： 1、计算条件表达式结果 2、结果为true，执行{}内的语句体 3、结果为false，直接跳出if结构 2)、双分支|双选择 ...
C语言基础——流程控制语句
老王的博客
03-25 1193
流程控制语句
day03-switch&循环语句.pdf
12-13
"Day03-Switch与循环语句" switch语句是Java中的一种选择结构，用于根据不同的值执行不同的语句。 switch语句的结构主要由switch表达式、case语句和default语句组成。switch表达式的值将与每个case语句的值进行比较...
day03-switch&循环语句
06-13
day03-switch&循环语句
day03-switch&循环语句1
08-04
【Java中的switch语句】 switch语句在Java中是一种选择结构，它允许程序根据不同的条件分支执行不同的代码块。在Java中，switch语句的基本结构如下： ```java switch(表达式) { case 常量1: // 语句1 break; ...
Java开发零基础篇：Day03 选择语句和循环语句.pdf
11-04
Java选择语句和循环语句 选择结构是Java中的一种基本控制结构，它允许程序根据条件执行不同的分支。选择结构也被称为分支结构，它可以根据逻辑判断，存在多个不同的结果，此时就会产生不同的选择，不同的选择执行...
基础语法&流程控制语句
chenghan的博客
08-13 210
文章目录1. 算术运算符2. 字符的+操作3. 字符串的+操作4. 赋值运算符5. 自增自减运算符6. 关系运算符7. 逻辑运算符8. 短路逻辑运算符9. 三元运算符10. 两只老虎案例11. 三个和尚案例12. 数据输入13. 三个和尚升级版案例14. 顺序结构15. if 结构16. if...else 结构17. if...else...if 结构18. 考试奖励案例 1. 算术运算符 2. 字符的+操作 3. 字符串的+操作 4. 赋值运算符 5. 自增自减运算符 6. 关系运算符 7. 逻辑运
流程控制语句—顺序、选择、循环
热门推荐
文泷Vincent的博客
06-06 1万+
流程控制语句—顺序、选择、循环1.  概述在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。在清楚每条语句的执行流程的前提下，才能通过控制语句的执行顺序来实现我们要完成的功能。2.  顺序控制语句2.1概述是程序中最简单的流程控制，按照代码执行的先后顺序，依次执行，程序中的大多数代码都是这样执行的。2.2顺序结构流程图2.3代码示例pu...
Python学习笔记(5)
liuyingsxty的博客
07-12 299
条件控制语句 1.条件判断语句 执行的流程 if语句在执行时，会先对条件表达式进行求值判断，如果为True，则执行if后的语句，如果为False，则不执行 语法：if 条件表达式： 代码块 代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行 代码块以缩进开始，直到代码恢复到之前的缩进级别时结束 代码块就是一种为代码分组的机制 2.input()函数 该函数用来获取用户的输入 input()调用后，程序会立即暂停，等待用户输入 用户输入完内容以后，点击回车程序才会继
c语言程序的流程控制语句,三 C语言流程控制语句
weixin_27918373的博客
05-20 432
简介：流程控制语句1.分支语句(条件语句)if/else(重点)switch/case2.循环语句for(重点)whiledo while分支语句1> if/else按照一定的条件执行不同的代码，可以使用分支语句。if(逻辑表达式条件1){ //如果 必须出现1次满足条件1时执行的语句;}else if(逻辑表达式条件2){ //或者 出现0-n次满足条件2时执行的语句;}else{...
break语句可以出现在switch语句和循环语句中。对吗？
05-31
是的，`break`语句可以出现在`switch`语句和循环语句中，用于在满足一定条件时跳出循环或者中断`switch`语句的执行。 在`switch`语句中，`break`语句可以用于结束当前`case`分支的执行，并跳出`switch`语句。例如： ```java switch (dayOfWeek) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; case 3: System.out.println("Wednesday"); break; // 省略其他case分支 default: System.out.println("Invalid day of week"); break; } ``` 在上述代码中，当`dayOfWeek`变量的值为`1`时，会执行`case 1`分支中的代码，并且遇到`break`语句后跳出`switch`语句。如果没有`break`语句，会继续执行下一个`case`分支的代码，直到遇到`break`语句或者`switch`语句结束。 在循环语句中，`break`语句可以用于结束当前循环的执行，并跳出循环。例如： ```java for (int i = 0; i < 10; i++) { if (i == 5) { break; // 当i等于5时跳出循环 } System.out.println(i); } ``` 在上述代码中，当`i`变量的值等于`5`时，会执行`break`语句并跳出循环，不再继续执行循环体中的其他语句。需要注意的是，`break`语句只能用于跳出当前循环，如果有嵌套循环，则只会跳出最内层的循环。如果需要跳出多层循环，可以使用带标签的`break`语句。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值