1-3 Java循环结构和方法

于 2022-10-22 20:17:07 发布
阅读量285 收藏 1
点赞数 1
分类专栏： Note 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WilsonDone/article/details/127466673
版权

作业

1. 下列代码有问题吗？
	float score = 3.14f; //有小数默认是double所以float需要添加f
	byte num = -128;   
	char gender = 'nan'; //char类型是字符--》 一个 

2. 下列代码的输出结果是？
    //字符串使用 + 相当于是字符串的拼接
	System.out.println("hello" + "world");helloworld
    //打印语句中是没有 字符串所以 这个常量值相当于是 两个数的相加
	System.out.println(98 + 12); 110 
    //字符串和任意类型 使用 + 默认就是字符串拼接，拼接的内容会形成字符串 
	System.out.println(13 + "" + 14); 1314
    //字符串类型是可以参与计算，参与计算的时候，根据字符，查找对应ASCII码表中十进制
	System.out.println(14 + 'A' + 12); 91
	
3. 下列代码的输出结果是？
	int a = 10;  
//++ -- 运算符  无论是++ 还是 -- 最终变量都需要进行+1 或 -1操作
//区分运算符是在变量之前 还是 变量之后
/*
运算符在变量之前，称为前++ ，变量本身会先进行一次+1操作，然后在参与其他运算
                  前--                   -1操作，
运算符在变量之后，称为后++ ，变量会先参运算，然后本身会进行一次+1操作
                  后--                               -1操作
*/
   //后++，先取出a变量值的进行打印，然后a变量会进行自增
	System.out.println(a++); //10  ---> 10+1  --->a = 11
   //前++，先获取a变量的值并进行一次自增运算，然后在参与打印
	System.out.println(++a);//11+1 ---> a = 12 ---> 12
   //后--，先取出a变量的值进行打印，然后a变量会进行自减
	System.out.println(a--);//12   ---> 12-1  --->a = 11
   //前--,先获取a变量的值并进行一次自减运算，然后在参与打印
	System.out.println(--a);//11-1 ---> a = 10 ---> 10

import java.util.Scanner;

/**
 * 作业
 */
public class HomeWork {
    public static void main(String[] args) {
         //2.输入三个不等，并将数据升序输出【升序从小到大】
        /**
         * random的随机数原则
         * [) -->左闭右开区间 --》包含做不包含右
         * 原始范围 [0,1) --> Math.random() ---》随机出的结果值是一个小数【double】
         * 假如要随机100以内的数据，不包括100
         * [0,1)*100 --->[0*100,1*100) -->[0,100) -->随机到100以内数据
         */
        int a = (int)(Math.random()*1000);
        int b = (int)(Math.random()*1000);
        int c = (int)(Math.random()*1000);
        //假设一个固定顺序 a 最小，b第二大，c是最大值
        //想尽所有办法保证a最小【只要把a最大的情况都排除即可】
        int tmp = 0;
        if(a>b){
            tmp = a;
            a = b;
            b = tmp;
        }//a可定比b小
        if(a>c){
            tmp = a;
            a = c;
            c = tmp;
        }//a肯定最小了
        if(b > c){
            tmp = b;
            b = c;
            c = tmp;
        }
        System.out.println(a+" "+b+" "+c);

        //4:有一个函数，当x<0，则y=-1；当x=0，y=0;当x>0,y=1,；编写一个程序，输入一个x值，输出一个y值。
        int x = (int)(Math.random()*100);
         x = x-30;
        if (x<0){
            System.out.println("y=-1");
        }else if(x == 0){
            System.out.println("y=0");
        }else if(x > 0 ){
            System.out.println("y=1");
        }

        //求出第三个数的最大值【最小值可以参考这个逻辑】
        int tmp2 = a > b ? a : b;//这个表达式肯定会得到a和b之间的最大值
        tmp2 = tmp2 > c ? tmp2 : c; //通过a和b之间的最大值和c进行比较得到最终最大值
        System.out.println("最大值是："+tmp2);
        //获取控制台上一个字符
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个字符：");
        char ch = input.next().charAt(0);
        if (ch>='0' && ch<='9'){
            System.out.println("是数字");
        }else if(ch>='a' && ch<='z'){
            System.out.println("是小写字母");
        }else if(ch>='A' && ch<='Z'){
            System.out.println("是大写字母");
        }else{
            System.out.println("其他字符");
        }
    }
}


import java.util.Scanner;

/**
 * 作业最后三个小题
 */
public class HomeWork2 {
    public static void main(String[] args) {
        /**
         * 12.水仙花数,是一个三位数
         * 个位立方+十位的立方+百位的立方 == 原来的数   153  如何获取个位 十位 和 百位
         * 百位数  153/100 = 1
         */
        int n = 153;
        //百位
        int a = n/100; // --> 153/100-->1
        //十位
        int b = n/10%10; // --> 153/10%10 --> 15%10 --> 5
        //个位
        int c = n%10;// 153%10 --> 3
        //Math.pow(被求的数据,次方) 次方计算的方
        if((Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3)) == n){
            System.out.println("是水仙花数："+n);
        }else{
            System.out.println("不是水仙花数："+n);
        }
         /* 13.输入一个时间，输出它的下一秒
         * 在控制台上输入一个时间例如： 20:30:30 --> 打印出来  20:30:31
         *                                                    20:30:59 --> 20:31：00
         *                                                    20:59:59 --> 21:00:00
         *                                                   23:59:59  --> 00:00:00
         * 这里的输出分别就是 小时，分钟 和 秒 --》 输出的时候必须是 小时:分钟：秒  --》 21:0：0
         *
         * PS：所有所学分支语句都是可以互相嵌套的
         * if(){
         *        if(){
         *         switch(){
         *                  case 1:
         *                       break
         *              }
         *     }
         * }
         */
        System.out.println("------------------------------华丽的分割线------------------------------");
        Scanner input  = new Scanner(System.in);
        System.out.println("请输入小时：");
        int h = input.nextInt();
        System.out.println("请输入分钟：");
        int m = input.nextInt();
        System.out.println("请输入秒：");
        int s = input.nextInt();
        //输出用户输入值的下一秒
        s++;  //秒+1
        if(s == 60){
            //秒要清0
            s = 0;
            //分钟要+1
            m++;
            if (m == 60){
                m = 0; // 分钟要清0
                h++;//小时要+1
                if(h == 24){
                    h = 0 ;//小时清0
                }
            }
        }
        System.out.println(h+":"+m+":"+s);

         /*
         * 14.输出这一年的第几天，需要考虑闰年的问题
         *  输入 2000-12-31  --》 打印是366天
         * 输入 2000-1 -1   --》 打印是1天
         *
         * 提示：先明确，这一年中过完了几个月例如 2000-5-1 ，过完了和这个年中的 4 3 2 1四个月，你在过5月份第一天
         *            1+4月份+3月份+2月份天数+1月份天数 == 总天数 需要注意2分月
         *
         *    2000-12-31 --> 2001-1-1 12-1
         */
        System.out.println("------------------------------华丽的分割线------------------------------");
        System.out.println("请输入年：");
        int year = input.nextInt();
        System.out.println("请输入月：");
        int month = input.nextInt();
        System.out.println("请输入日期：");
        int day = input.nextInt();
        //计算:
        switch (month-1){//求出过完了多少个月
            case 11:
                day += 30;
            case 10:
                day += 31;
            case 9:
                day += 30;
            case 8:
                day += 31;
            case 7:
                day += 31;
            case 6:
                day += 30;
            case 5:
                day += 31;
            case 4:
                day += 30;
            case 3:
                day += 31;
            case 2:
                if((year%4==0 && year%100!=0)||(year%400==0)){
                    day += 29;
                }else{
                    day+=28;
                 }

            case 1:
                day += 31;
                System.out.println("这是这一年的第："+day+"天");
                break;
            default:
                System.out.println("这是这一年的第："+day+"天");
                break;

        }




    }
}

Java中的循环

PS：Java中程序的组成【顺序，分支，循环】

如果在程序中需要重复执行某个指令（代码），此时就需要使用到循环了

在这里插入图片描述

在这里插入图片描述

Java中常见的循环有**【while循环、do-while循环、for循环】**

PS：重点掌握for循环，其次while循环，最后do-while

写循环的要求:

1.重复操作事情【重复执行代码什么】

2.循环次数【重复多少遍】

while循环

语法：

PS：循环中重复的次数在程序的表现形式 ---》 一个范围判断  ---》 循环条件
    既然做一个范围，那么就需要有一个开始的位置  ---》循环的起始点
    ---》通过这个起始点作为一个范围，判断这个范围，如果是在范围允许内的---》重复操作这个事情
    ---》如果不在这个范围内 ---》不执行
    

循环变量赋初值; //循环开始的位置
while(循环条件){ // 循环变量和你知道的循环次数 作为一个范围【循环次数】
      重复操作的事情;  //重复执行代码
      控制循环变量的自增或自减; // 让循环趋于结束
}

说明：
 1.while 是一个关键字
 2.循环变量赋初值【基本上都是整数】，作用定义循环开始位置即起始点
 3.循环条件【表达式】，作用起到对循环次数的控制【即控制循环范围】
   表达式组成： 一般是由关系和逻辑运算符组成
   PS：
      "1.既然是关系和逻辑运算符，组成的表达式结果只有 true 和 false"
      "2.一般多使用关系运算符作为，循环范围出现，常使用运算符【> >= < <=】"
      "3.偶尔可见关系和逻辑运算符一次使用，常使用运算符【 == != && ||】"
      "4.既然while循环的表达式是一个boolean类型，所以while循环条件就允许单独写 true 或 false"
 4.{} 循环体，需要重复执行的代码都写到这个循环体中
   PS：
     "1.执行语句，就是重复代码【这个代码可以有N行】"
     "2.循环变量的控制，就让循环趋于结束 ，让循环变量进行自增或自减"
     
执行过程：
     当程序执行到循环变量赋初值的时候，先对循环变量进行初始化，然后执行while循环后循环条件判断，如果循环挑那判断为 true 就会执行{} 中的执行语句，执行语句执行完毕之后，会进行循环变量的自增或自减操作，会继续判断循环条件是否成立【判断是true还是false】，只要为 true 就继续执行之前的操作，否则【为false】循环结束

案例1

/**
 * 基础案例：
 */
public class WhileDemo1 {
    public static void main(String[] args) {
        //1.输出10遍你好
        /*
         分析：
          10 是循环执行次数 ---》 做一个范围满足这个次数
          输出你好 ---》重复操作的事情
         */
        //循环变量赋初值
        int i = 0;
        while(i<10){//循环条件
            //重复的事情
            System.out.println("你好");
            //对循环变量自增或自减，以达到对循环的控制
            i++;
        }
    }
}

案例2

/**
 * 基础案例2：
 */
public class WhileDemo2 {
    public static void main(String[] args) {
        //1.打印100以内所有 奇数、偶数和3的倍数
        /*
         分析：
          100是循环执行次数 ---》 做一个范围满足这个次数
          重复操作的事情就是对数据的计算
          重复计算 奇数   重复计算 偶数    重复计算3的倍数
          谁可以做到这个计算？
          循环变量赋初值，也看开始的位置，我们控制这个循环变量是不断变化
          变化的范围真正好是在 100以内，所以就可以使用这个循环变量来参与这个运算
         */
        //1.循环变量赋初值
        int i =1;
        while(i < 100){ //循环循环条件
            //重复操作的事情
            if(i%2 == 1){
                System.out.println("奇数："+i);
            }
            if(i%2 == 0){
                System.out.println("偶数："+i);
            }
            if(i%3 == 0){
                System.out.println("3的倍数："+i);
            }
            //控制循环变量让循环循环停止
            i++;

        }

    }
}

PS：循环变量赋初值有两种存在的目的：

1.单纯的只为了循环条件而存在，不会参与到执行语句中计算

2.除了控制循环次数之外，也会参与到执行语句中计算

总结：

while循环是仅次于for循环而存在一个循环，循环的特点就是while循环后面循环条件是一个boolean表达式，所以利用这个原则写一个死循环，只要表达式的始终为true就是死循环，如果循环过程中是一个单纯的boolean表达式，建议优先使用while循环

PS：死循环书写---》 无限循环 
   while(true){
       //重复执行操作语句会一直执行
   }

do-while循环

PS:do-while循环和while循环有一些类似，之间可以看做时一个"亲戚"关系，do-while循环是while循环的倒写

语法：

循环变量赋初值
do{
    执行语句：
    循环变量的自增或自减;  
}while(循环条件);    

说明：
    1. do while 都是关键字
    2.循环变量赋初值【基本上都是整数】，作用定义循环开始位置即起始点
    3.循环条件【表达式】，作用起到对循环次数的控制【即控制循环范围】
      表达式组成： 一般是由关系和逻辑运算符组成
     PS：
       "1.既然是关系和逻辑运算符，组成的表达式结果只有 true 和 false"
       "2.一般多使用关系运算符作为，循环范围出现，常使用运算符【> >= < <=】"
       "3.偶尔可见关系和逻辑运算符一次使用，常使用运算符【 == != && ||】"
       "4.既然while循环的表达式是一个boolean类型，所以while循环条件就允许单独写 true 或 false"
    4.{} 循环体，需要重复执行的代码都写到这个循环体中
     PS：
       "1.执行语句，就是重复代码【这个代码可以有N行】"
       "2.循环变量的控制，就让循环趋于结束 ，让循环变量进行自增或自减"
展示while循环和do-while循环的不同
/**
 * 演示do-while循环
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        //使用while循环和do-while循环完成1-10的打印
        System.out.println("-----------------------------while循环-----------------------------");
        int i = 1;
        while(i<10){
            System.out.println(i);
            i++;
        }
        System.out.println("-----------------------------do-while循环-----------------------------");
        //1.循环变量赋初值
        int j = 1;
        do {
            //重复操作的事情
            System.out.println(j);
            //循环变量的自增
            j++;
        }while(j<10);//循环条件
    }
}

总结：

本质上do-while循环和while循环是一样的，无论是操作重复的事情还是控制重复的次数都是一样，只不过do-while循环是while循环的倒写

极端修改代码
PS：将判断条件统一设置为 i<1  和 j<1
    /**
 * 演示do-while循环
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        //使用while循环和do-while循环完成1-10的打印
        System.out.println("-----------------------------while循环-----------------------------");
        int i = 1;
        while(i<1){
            System.out.println(i);
            i++;
        }
        System.out.println("-----------------------------do-while循环-----------------------------");
        //1.循环变量赋初值
        int j = 1;
        do {
            //重复操作的事情
            System.out.println(j);
            //循环变量的自增
            j++;
        }while(j<1);//循环条件
    }
}

说明do-while循环执行的方式和while区别

1.do-while 的执行：
  当程序执行到do-while循环的时候，首先会先执行do后面{}中的执行语句，然后循环变量会进行自增或自减，在去判断循环条件是否成，如果循环条件成立，会在此执行do后面{}中的语句，如果循环循环条件不成立，循环会终止
2.do-while 和 while 循环的区别 
  do-while 循环 先执行语句，然后在判断循环条件是否成立
  while    循环 先执行判断循环条件是否成立，然后在执行语句

for循环

语法：

for(循环变量赋初值;循环条件;循环变量的自增或自减){
 		执行语句;   
}  
说明：
    1. for 是关键字
    2.循环变量赋初值【基本上都是整数】，作用定义循环开始位置即起始点
    3.循环条件【表达式】，作用起到对循环次数的控制【即控制循环范围】
      表达式组成： 一般是由关系和逻辑运算符组成
     PS：
       "1.既然是关系和逻辑运算符，组成的表达式结果只有 true 和 false"
       "2.一般多使用关系运算符作为，循环范围出现，常使用运算符【> >= < <=】"
       "3.偶尔可见关系和逻辑运算符一次使用，常使用运算符【 == != && ||】"
       "4. for循环的循环条件也是boolean表达式，默认不写就是true"
    4.循环变量的控制，就让循环趋于结束 ，让循环变量进行自增或自减"     
    5.{} 循环体，需要重复执行的代码都写到这个循环体中
     PS：
       "1.执行语句，就是重复代码【这个代码可以有N行】"
        
问题：
    1.for循环中的循环变量赋初值
    因为for循环的循环变量赋初值，定义在当前for的小括号中，所以这个变量只能在for中使用
    这个变量在java中称为"局部变量" 
    PS:或者可以称为"密封变量"  --》C#语言
    2.for循环的基础条件都是写到小括号中，所以每一个条件写完都需要使用【;】    
    3.for循环也支持"死循环的写法"，默认不写循环条件，就是死循环
        
执行过程：
    当程序执行到for循环的时候，首先会进行循环变量和赋初值操作【1次】，然后会判断循环条件【多次】，如果循环条件成立【为true】，就执行{}循环体，执行重复操作的事情，会继续执行循环变量自增或自减【多次】，继续判断循环条件，直到循环条件不成立【为false】，循环才会结束

案例1:

/**
 * for循环的基础案例
 */
public class ForDemo1 {
    public static void main(String[] args) {
        //1.打印从0开始到10结束，中间所有值输出
        /*
        分析：
          重复次数 --》 因为是从0开始到10结束 所以范围就是0~10之间
          重复操作的事情 --》 打印0~10之间的值
         */
      //  for(循环变量赋初值;循环条件;循环变量的自增或自减)
        for(int i = 0;i<10;i++){
            System.out.println(i);
        }
    }
}

案例2

求出1-100之间所有数的和包括100
    /**
 * for循环的案例【求和】
 */
public class ForDemo2 {
    public static void main(String[] args) {
        //1.计算1-100以内所以数的和包括100
        /*
        分析：
          次数 --》100次 ---》范围 1~100之间包含100---》就不能只使用<【小于号】 需要是使用<=【小于等于】
          重复事情： 求出1~100之内所有数据的和  有一个计数的变量 ，存储着数据和
         */
        //1.创建一个变量，用来存储数据的和，这个变量的初始值不能影响最终计算结果
        //PS:一般做求和计算的时候，存储和的变量初始值都为0，因为0不会影响计算结果
        int sum = 0;
        for (int  i = 1; i<=100; i++){
            //求和
           // sum = sum+i;// 0+1+2+3+4+5+6+7+8+.....+100
            //如果表达式的计算最终结果赋值给参与表达式计算变量，使用复合运算符
            sum += i;
        }
        System.out.println("和是："+sum);
    }
}

案例3

求出5！？ --》 相当于求出5的阶乘   ---》 1*2*3*4*5
    /**
 * for循环的案例【求阶乘】
 */
public class ForDemo3 {
    public static void main(String[] args) {
        //1.计算5！ --》 1*2*3*4*5
        /*
        分析：
          次数 --》5 ---》范围 1~5 因为阶乘是包含最后一位值，所以需要使用<=
          重复事情： 求出1~5乘积  有一个计数的变量 ，存储着乘积
          PS：千万不要小看乘积，因为就这个计算是恐怖的，轻易之间就会超过存储范围
         */
        //1.创建一个变量，用来存储数据乘积的时候，这个变量的初始值不能影响最终计算结果
        //PS:一般做求乘积计算的时候，存储和的变量初始值都为1，因为1不会影响计算结果
        int num = 1;
        for (int  i = 1; i<=5; i++){
            //如果表达式的计算最终结果赋值给参与表达式计算变量，使用复合运算符
            num *= i;
        }
        System.out.println("乘积是："+num);
    }
}

练习：

在这里插入图片描述

/**
 * 已知第一位和第二位都是1，从第三为开始 等于前前两位之和， 求出前20位之和
 */
public class FibonacciDemo {
    public static void main(String[] args) {
        //1.定义两个变量，这个两个变量存储就着1和1的值
        int n1 = 1;
        int n2 = 1;
  
        //2.在定义一个变量这个变量存储存第三位的值
        int n3 = 0;
        //3. 求出当前菲波那切数列求出前20位和 1+1+2+3+5+8....
        //在定义这个初始变量的时候，先求出前两位值和
        int sum = n1 + n2;
        //4.因为已经将前2两位的和计算了，所以循环次数就需要从原有20次变成18
        for(int  i = 0;i<18;i++){
            //先求出第3位
            n3 = n1+n2;
            System.out.println("n3 = "+n3);
            //累加计算和
            sum = sum + n3;  //第一次循环相当于是 n1+n2+n3的值
            //5.需要循环求出以后的每一位n3， n3前两位之和
            //为了求出全新的一位n3，只需要将原有n2的值赋值给n1  原有n3值赋值给n2
            //这样做的话，相当于是移动位置
            n1 = n2;
            n2 = n3;
        }
        System.out.println("和是:"+sum);



    }
}

for循环的6种写法

/**
 *  6种写法
 */
public class ForDemo4 {
    public static void main(String[] args) {
        //1.标准写法
        for(int i = 0;i<10;i++){
            System.out.println(i);
        }
        //2.将循环变量赋初值，定义在循环体的外部
        //2.1定义在外部并赋值,此时这个变量就在循环的外部可以访问了
        int i = 1;
        for(;i<10;i++){
            System.out.println(i);
        }
        //2.2在外部定义，在内部赋值,此时这个变量就在循环的外部可以访问了
        int i;
        for(i = 0 ;i<10;i++){
            System.out.println(i);
        }
        //PS：在外部获取的到的i值是，当前循环结束的值

        //3.for循环死循环写法的第一种，不写循环条件【默认true】
        for(int i = 0;;i++){
            System.out.println(i);
        }
        //4.将循环变量的自增或自减写入到循环体中
        for(int i = 0;i<10;){
            System.out.println(i);
            i++;
        }
        //5.仿照while循环书写
        int i = 0;
        for(;i<10;){
            System.out.println(i);
            i++;
        }
        //6.for循环死循环写法第二种
        int i= 0;
        for(;;){
            System.out.println(i);
            i++;
        }

     

    }
}

循环嵌套

PS：所有的循环都是允许嵌套，这里仅以for循环为例讲解

说明：
    1.嵌套循环指的是在循环体内有另外一个循环，即重复执行事情时另外一个循环
    2.在外层的循环 --> 外层循环
    3.在外层循环的内部  --> 内层循环
    例如：
    for(int i = 1;i<10;i++){  // --> 外层循环
       for(int j = 1;j<10;j++){ // --> 内层循环
           //此时就是循环嵌套
       }   
    }
    ps：
        1."外层循环执行1次，内层循环执行多次"
        2."内层循环不结束，外层循环无法开启下一次"
        3."外层循环的【循环变量】可以参与到内层循环中进行计算"
        4."外层循环的【循环变量】可以对内层循环的【循环条件】进行限制"
 通过嵌套循环可以解决：数据的排序，图形的打印，程序中访问位置的嵌套【使用循环方式遍历文件夹】
 
 通俗理解：
        将循环嵌套看做时一本书，外层循环相当于是书中每一页，内层循环相当于是每一页中每一个行内容，只有看完当前页的每一行内容，才可以翻页---》【相当于】---》 内层循环执行完毕之后，才能开启外层循环

需求：

输出一个矩阵：
1	2	3	4	5
2	4	6	8	10
3	6	9	12	15
4	8	12	16	20
    
/**
 * 嵌套循环
 */
public class ForDemo5 {
    public static void main(String[] args) {
        /*
            1	2	3	4	5
            2	4	6	8	10
            3	6	9	12	15
            4	8	12	16	20
         */
        for(int j = 1;j<=4;j++) {
            for (int i = 1; i <= 5; i++) {
                // 转义字符  --> \t  --> tab【四个空格】
                System.out.print(i*j + "\t");
            }
            System.out.println();
        }
    }
}

三个关键字break，continue，return

PS：这三个关键字都可以用来对循环进行操作**【return是一个特殊】**

break关键字

若不需要在通过循环条件停止循环的前提下，可以使用break关键字

PS:正常循环停止是因为，当前的循环添加为false，不想为false时停止循环，而是达到某个条件的时候停止，就可以使用break关键字

​ break关键字只能给循环和switch使用

break的一个小问题

break关键字只能停止当前循环【当前这层】，如果是嵌套循环，需要将循环都停止，就建议在最外层循环的位置添加一个“标签”，可以标记循环的名字，使用break的时候可以对这个带有标签名字循环进行终止，已达到对嵌套循环的停止

案例：

/**
 * break关键字的使用
 */
public class BreakDemo {
    public static void main(String[] args) {
        //1.一层循环使用break
        for(int  i = 0;i<10;i++){
            //当i值等于5的时候，让循环停止
            if(i == 5){
                break;
            }
            System.out.println(i);
        }
        //2.  嵌套循环中break在哪个循环中使用，停止哪个循环
        EXIT:for(int n = 1;n<=3;n++){
            for(int m = 1;m<=3;m++){
                //当m等于2的时候让所有循环都停止,在外层循环的前面添加标签，使用break关键字 指定关闭哪个循环
                if(m == 2){
                    break EXIT;
                }
                System.out.println("n="+n+","+"m="+m);
            }
        }
    }
}

Continue关键字

continue关键字是跳过本次循环，开始下一次循环

/**
 * continue关键字
 * 
 */
public class ContinueDemo {
    public static void main(String[] args) {
        //计算100~200之间不能被3整除数据
        for(int i = 100;i<=200;i++){
            if(i % 3 == 0){//判断条件是整除3
                continue;
            }
            System.out.println("不能被3整数的数字："+i);
        }
    }
}

说明：

break是完全终止循环，而Continue是停止当前循环，让循环开启下一次，它的式根据循环条件为false结束

return关键字

ps：return关键字本质是结束一个方法，而不是结束循环，为什么使用return关键可以让循环停止，因为循环是写在方法体的内部，方法都没有了，循环自然不存在了，无论是多少层循环都停止 。

/**
 * 简单使用
 */
public class ReturnDemo {
    public static void main(String[] args) {
     
       for(int n = 1;n<=3;n++){
            for(int m = 1;m<=3;m++){
                //当m等于2的时候让所有循环都停止
                if(m == 2){
                    //谨慎在main方法使用return
                    return;
                   // break EXIT;
                }
                System.out.println("n="+n+","+"m="+m);
            }
        }
       
       
    }
}
Doub1eOne
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值