【JAVA基础】03 Java语言基础

前言：流程控制语句

• 什么是流程控制语句

  • 流程控制语句：可以控制程序的执行流程。

• 流程控制语句的分类

  • 顺序结构

  • 选择结构

  • 循环结构

• 执行流程：

  • 从上往下，依次执行。

• 案例演示

  • 输出几句话看效果即可

  • class Demo1_Sequence {                            //sequence 顺序
        public static void main(String[] args) {
            System.out.println("Hello World!11111");
            System.out.println("Hello World!3333");
            System.out.println("Hello World!22222");
            System.out.println("Hello World!44444");
        }
    }

1. 选择结构

1.1 选择结构if语句

• 选择结构的分类

  • if语句

  • switch语句

• if语句有几种格式

  • 格式1

    • if (比较表达式) { 语句体; }

    • /*
      * C:if语句的格式1
      *
              if(比较表达式) {
                  语句体;
              }
      * D:执行流程：
          * 先计算比较表达式的值，看其返回值是true还是false。
          * 如果是true，就执行语句体；
          * 如果是false，就不执行语句体；
      */
      class Demo1_If {
          public static void main(String[] args) {
              int age = 17;
      
              if (age >= 18) {
                  System.out.println("可以浏览本网站");
              }
      
              System.out.println("完了");
          }
      }

  • 格式2

    • if (比较表达式)  {
      语句体1;
      }else {
      语句体2;
      }

    • /*
      * A:if语句的格式2
      *
              if(比较表达式) {
                  语句体1;
              }else {
                  语句体2;
              }
      * B:执行流程：
          * 首先计算比较表达式的值，看其返回值是true还是false。
          * 如果是true，就执行语句体1；
          * 如果是false，就执行语句体2；
      * C:案例演示
          * a:获取两个数据中较大的值
          * b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
      
          * 注意事项：else后面是没有比较表达式的，只有if后面有。
      */
      class Demo3_If {
          public static void main(String[] args) {
              /*int x = 0;
              if (x == 1) {
                  System.out.println("男厕所欢迎您");
              }else {
                  System.out.println("女厕所欢迎您");
              }*/
      
              //a:获取两个数据中较大的值
              /*int x = 10;
              int y = 20;
              int z;
      
              if (x > y) {
                  z = x;
              }else {
                  z = y;
              }
      
              System.out.println(z);*/
      
              //b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
              int num = 11;
              if (num % 2 == 0) {
                  System.out.println(num + "是一个偶数");
              }else {
                  System.out.println(num + "是一个奇数");
              }
          }
      }

  • 格式3

    • if (比较表达式1)  {
      语句体1;
      }else if (比较表达式2)  {
      语句体2;
      }else if  (比较表达式3) {
      语句体3;
      }
      ...
      else {
      语句体n+1;
      }

    • /*
      * A:if语句的格式3：
      *
              if(比较表达式1) {
                  语句体1;
              }else if(比较表达式2) {
                  语句体2;
              }else if(比较表达式3) {
                  语句体3;
              }
              ...
              else {
                  语句体n+1;
              }
      * B:执行流程：
          * 首先计算比较表达式1看其返回值是true还是false，
          * 如果是true，就执行语句体1，if语句结束。
          * 如果是false，接着计算比较表达式2看其返回值是true还是false，
      
          * 如果是true，就执行语句体2，if语句结束。
          * 如果是false，接着计算比较表达式3看其返回值是true还是false，
      
          * 如果都是false，就执行语句体n+1。
      * C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示
      */
      class Demo5_If {
          public static void main(String[] args) {
              int x = 2;
              if (x == 1) {
                  System.out.println("男厕所欢迎您");
              }else if (x == 0) {
                  System.out.println("女厕所欢迎您");
              }else {
                  System.out.println("无法识别您的性别");
              }
          }
      }

• 选择结构if语句注意事项
  • 比较表达式无论简单还是复杂，结果必须是boolean类型
  • if语句控制的语句体如果是一条语句，大括号可以省略；
    • 如果是多条语句，就不能省略。建议永远不要省略。
  • 一般来说：有左大括号就没有分号，有分号就没有左大括号

  • /*
    *    a:比较表达式无论简单还是复杂，结果必须是boolean类型
        * b:if语句控制的语句体如果是一条语句，大括号可以省略；
          * 如果是多条语句，就不能省略。建议永远不要省略。
        * c:一般来说：有左大括号就没有分号，有分号就没有左大括号
    
    */
    class Demo2_If {
        public static void main(String[] args) {
            int age = 17;
    
            if (age >= 18 && age <= 60) {
                System.out.println("可以浏览本网站");
                //int x = 10;                是两句话,int x声明是一句,x = 10 赋值是一句
            }
            System.out.println("完了");
    
        }
    }

• if语句的格式2和三元的相互转换问题
  • if语句和三元运算符完成同一个效果

    • /*
      * A:案例演示
          * if语句和三元运算符完成同一个效果
      * B:案例演示
          * if语句和三元运算符的区别
      
          * 三元运算符实现的，都可以采用if语句实现。反之不成立。
      
          * 什么时候if语句实现不能用三元改进呢?
              * 当if语句控制的操作是一个输出语句的时候就不能。
              * 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
      
      */
      class Demo4_If {
          public static void main(String[] args) {
              int x = 10;
              int y = 20;
              int z;
      
              if (x > y) {
                  //z = x;
                  System.out.println(x + "是最大值");
              }else {
                  //z = y;
                  System.out.println(y + "是最大值");
              }
      
              //System.out.println(z);
      
              int a = 20;
              int b = 30;
      
              int c = (a > b)? a : b;
          }
      }

• • if语句和三元运算符的区别

    • 三元运算符实现的，都可以采用if语句实现。反之不成立。

  • 什么时候if语句实现不能用三元改进呢?

    • 当if语句控制的操作是一个输出语句的时候就不能。

    • 为什么呢？因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

• 选择结构if语句的嵌套使用

  • /*
    * A:案例演示
        * 需求：获取三个数据中的最大值
        * if语句的嵌套使用。
    */
    class Demo6_IfIf {
        public static void main(String[] args) {
            int a = 40;
            int b = 50;
            int c = 30;
    
            if (a > b) {
                if (a > c) {
                    System.out.println(a + "是最大值");
                }else {
                    System.out.println(c + "是最大值");
                }
    
            }else {    //b >= a
                if (b > c) {
                    System.out.println(b + "是最大值");
                }else {
                    System.out.println(c + "是最大值");
                }
            }
        }
    }

1.2  选择结构switch语句

• switch语句的格式

  • switch (表达式)  {                        //基本数据类型可以接收byte,short,char,int
    case 值1：                               //引用数据类型可以接收枚举(JDK1.5)，String字符串(JDK1.7)
             语句体1;
        break;
    case 值2：
             语句体2;
        break;
         …
    default：
             语句体n+1;
        break; }

• switch语句的格式解释

• 面试题

  • byte可以作为switch的表达式吗?

    • 可以。所有计算可以自动补位到int类型的，都可以

  • long可以作为switch的表达式吗?

    • 不可以

  • String可以作为switch的表达式吗?

    • 1.7版本JDK后可以

• 执行流程

  • 先计算表达式的值

  • 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句

  • class Demo1_Switch {
        public static void main(String[] args) {
            /*
            * A:switch语句的格式
            *        int x = 10;
                    switch(表达式) {        //基本数据类型可以接收byte,short,char,int
                          case 值1：        //引用数据类型可以接收枚举(JDK1.5)String字符串(JDK1.7)
                            语句体1;
                            break;
                            case 值2：
                            语句体2;
                            break;
                            …
                            default：
                            语句体n+1;
                            break;
                    }
    
            * B:switch语句的格式解释
            * C:面试题
                * byte可以作为switch的表达式吗?
                * long可以作为switch的表达式吗?
                * String可以作为switch的表达式吗?
            * C:执行流程
                * 先计算表达式的值
                * 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句
            */
    
            String name = "rose";
            String gender = "女";
            switch (gender) {
            case "男士":
                System.out.println(name + "是一位" + gender + "喜欢吃饭睡觉打dota");
            break;
            case "女士":
                System.out.println(name + "是一位" + gender + "喜欢逛街购物美容");
            break;
            default:
                System.out.println(name + "是一位" + gender + "打雌性激素维持美貌容颜");
            break;
            }
        }
    }

• 选择结构switch语句的练习

  • 整数(给定一个值,输出对应星期几)

  • class Test1_Switch {
        public static void main(String[] args) {
            //* A:整数(给定一个值,输出对应星期几)
            int week = 1;
            switch (week) {
            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;
            }
        }
    }

• 选择结构switch语句的注意事项

  • 案例演示

    • case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

    • default可以省略吗?

      • 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。

      • 特殊情况：

        • case就可以把值固定。

        • A,B,C,D

    • break可以省略吗?

      • 最后一个可以省略，其他最好不要省略

      • 会出现一个现象：case穿透。

      • 最终我们建议不要省略

    • default一定要在最后吗?

      • 不是，可以在任意位置。但是建议在最后。

    • switch语句的结束条件

      • 遇到break就结束了

      • 执行到switch的右大括号就结束了

• 选择结构switch语句练习

  • 看程序写结果：

  • class Test2_Switch {
        public static void main(String[] args) {
            // A:看程序写结果：
    
            /*int x = 2;
            int y = 3;
            switch(x){
                default:
                    y++;
                    break;
                case 3:
                    y++;
                case 4:
                    y++;
            }
            System.out.println("y="+y); // 输出4  */
    
        //B:看程序写结果：
    
            int x = 2;
            int y = 3;
            switch(x){
                default:
                    y++;
                case 3:
                    y++;
                case 4:
                    y++;
            }
            System.out.println("y="+y); // 输出6
        }
    }

    • 省略了break，会出现case穿透现象，导致逻辑出错

• 选择结构if语句和switch语句的区别

  • 总结switch语句和if语句的各自使用场景

    • switch建议判断固定值的时候用

    • if建议判断区间或范围的时候用

  • 案例演示

    • 分别用switch语句和if语句实现下列需求：

      • 键盘录入月份，输出对应的季节

      • import java.util.Scanner;
        class Test3_SwitchIf {
            public static void main(String[] args) {
                /*
        
                * 键盘录入月份，输出对应的季节
                一年有四季
                3,4,5春季
                6,7,8夏季
                9,10,11秋季
                12,1,2冬季
                */
                Scanner sc = new Scanner(System.in);    //创建键盘录入对象
                System.out.println("请输入月份");
                int month = sc.nextInt();                //将键盘录入的结果存储在month
                /*switch (month) {
                case 3:
                case 4:
                case 5:
                    System.out.println(month + "月是春季");
                break;
                case 6:
                case 7:
                case 8:
                    System.out.println(month + "月是夏季");
                break;
                case 9:
                case 10:
                case 11:
                    System.out.println(month + "月是秋季");
                break;
                case 12:
                case 1:
                case 2:
                    System.out.println(month + "月是冬季");
                break;
                default:
                    System.out.println("对不起没有对应的季节");
                break;
                }*/
        
                //用if语句来完成月份对应季节
                if (month > 12 || month < 1) {
                    System.out.println("对不起没有对应的季节");
                }else if (month >= 3 && month <= 5) {
                    System.out.println(month + "月是春季");
                }else if (month >= 6 && month <= 8) {
                    System.out.println(month + "月是夏季");
                }else if (month >= 9 && month <= 11) {
                    System.out.println(month + "月是秋季");
                }else {
                    System.out.println(month + "月是冬季");
                }
            }
        }

2. 循环结构

2.1 循环结构概述

• 循环结构的分类

  • for

  • while

  • do...while

2.2 循环结构——for语句

• 格式：

  • for (初始化表达式;条件表达式;循环后的操作表达式) {
    　　循环体;
    }

• 执行流程：

  • 执行初始化语句

  • 执行判断条件语句，看其返回值是true还是false

    • 如果是true，就继续执行

    • 如果是false，就结束循环

  • 执行循环体语句;

  • 执行循环后的操作表达式  （在循环体执行完成后，执行 i++，或 i--）

  • 回到执行判断条件语句，看其返回值是true还是false

• 案例演示

  • 在控制台输出10次"helloworld"

  • /*
    * A:循环结构的分类
        * for,while,do...while
    * B:循环结构for语句的格式：
    *
            for(初始化表达式;条件表达式;循环后的操作表达式) {
                循环体;
            }
    * C执行流程：
        * a:执行初始化语句
        * b:执行判断条件语句,看其返回值是true还是false
            * 如果是true，就继续执行
            * 如果是false，就结束循环
        * c:执行循环体语句;
        * d:执行循环后的操作表达式
        * e:回到B继续。
    * D:案例演示
        * 在控制台输出10次"helloworld"
    */
    class Demo1_For {
        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");*/
    
            for (int i = 1;i <= 10 ;i++ ) {
                System.out.println(i + " helloworld");
            }
        }
    }

• 案例演示

  • 需求：请在控制台输出数据1-10

  • 需求：请在控制台输出数据10-1

  • /*
    * A:案例演示
        * 需求：请在控制台输出数据1-10
        * 需求：请在控制台输出数据10-1
    * B:注意事项
        * a:判断条件语句无论简单还是复杂结果是boolean类型。
        * b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
        * c:一般来说：有左大括号就没有分号，有分号就没有左大括号
    */
    class Test1_For {
        public static void main(String[] args) {
            for (int i = 1;i <= 10 ;i++ ){
                System.out.println("i = " + i);
            }
            System.out.println("-----------------------");
    
            for (int i = 10;i >= 1 ;i-- ) {
                System.out.println("i = " + i);
            }
        }
    }

• 注意事项

  • 判断条件语句无论简单还是复杂结果是boolean类型。

  • 循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。

  • 一般来说：有左大括号就没有分号，有分号就没有左大括号

• 案例演示

  • 需求：求出1-10之间数据之和

  • 需求：求出1-100之间偶数和

  • 需求：求出1-100之间奇数和

  • /*
    * A:案例演示
        * 需求：求出1-10之间数据之和
    * B:学生练习
        * 需求：求出1-100之间偶数和
        * 需求：求出1-100之间奇数和
    
        分析:1-10数据的和
        0 + 1
            1 + 2
                3 + 3
                    6
                    ...
    */
    class Test2_For {
        public static void main(String[] args) {
            //1-10的和
            /*int sum = 0;
            for (int i = 1;i <= 10 ;i++ ) {
                sum = sum + i;
            }
    
            System.out.println("sum = " + sum);*/
    
            //1-100的偶数和
            /*int sum = 0;
            for (int i = 1;i <= 100 ;i++ ) {
                if (i % 2 == 0) {
                    sum = sum + i;
                }
            }
    
            System.out.println("sum = " + sum);*/
    
            //1-100的奇数和
            int sum = 0;
            for (int i = 1;i <= 100 ;i+=2 ) {
                /*if (i % 2 != 0) {
                    sum = sum + i;
                }*/
                sum = sum + i;
            }
    
            System.out.println("sum = " + sum);
        }
    }

• “水仙花数”案例演示

  • 需求：在控制台输出所有的”水仙花数”

  • 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。

  • 举例：153就是一个水仙花数。

    • 153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153

  • /*
    * A:案例演示
        * 需求：在控制台输出所有的”水仙花数”
    
        * 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
        * 举例：153就是一个水仙花数。
        * 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
    
        分析:
        1,100 - 999
        2,获取每一个位数的值,百位,十位,个位
        3,判断各个位上的立方和是否等于这个数,如果等于打印
    */
    class Test3_Flower {
        public static void main(String[] args) {
            for (int i = 100;i <= 999 ;i++ ) {                    //获取100到999之间的数
                int ge = i % 10;                                //123 % 10
                int shi = i / 10 % 10;                            //12 % 10;
                int bai = i / 10 / 10 % 10;                        //1 % 10
    
                if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                    System.out.println(i);
                }
            }
        }
    }

2.3 循环结构——while语句

• 循环结构while语句的格式：

  • while循环的基本格式：
    while (判断条件语句)  {
         循环体语句;
    }

  • 完整格式：

    • 初始化语句;
      while  (判断条件语句)  {
          循环体语句;
          控制条件语句;
      }

• 执行流程：
• 执行初始化语句

• 执行判断条件语句,看其返回值是true还是false

  • 如果是true，就继续执行

  • 如果是false，就结束循环

• 执行循环体语句;

• 执行控制条件语句

• 回到执行判断语句，继续循环，直到条件语句不满足。

• 案例演示
  • 需求：请在控制台输出数据1-10

  • /*
    * A:循环结构while语句的格式：
    *
            while循环的基本格式：
            while(判断条件语句) {
                循环体语句;
            }
    
            完整格式：
    
            初始化语句;
            while(判断条件语句) {
                 循环体语句;
                 控制条件语句;
            }
    * B:执行流程：
        * a:执行初始化语句
        * b:执行判断条件语句,看其返回值是true还是false
            * 如果是true，就继续执行
            * 如果是false，就结束循环
        * c:执行循环体语句;
        * d:执行控制条件语句
        * e:回到B继续。
    * C:案例演示
        * 需求：请在控制台输出数据1-10
    */
    class Demo1_While {
        public static void main(String[] args) {
            int x = 1;
            while (x <= 10) {
                System.out.println("x = " +  x);
                x++;
            }
        }
    }

• 案例演示
  • 求和：求1-100的和
  • 统计：统计水仙花数 有多少个

  • class Test1_While {
        public static void main(String[] args) {
            /*
            * A:求和思想
                * 求1-100之和
            * B:统计思想
                * 统计”水仙花数”共有多少个
            */
    
            //求1-100之和
            /*int sum = 0;
            int i = 1;
            while (i <= 100) {
                sum += i;                    //sum = sum + i;
                i++;                        //让变量i自增
            }
    
            System.out.println("sum = " + sum);*/
    
            //统计”水仙花数”共有多少个
            int count = 0;                    //计数器
            int i = 100;
            while (i <= 999) {
                int ge = i % 10;
                int shi = i / 10 % 10;
                int bai = i / 100;
    
                if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
                    count ++;
                }
    
                i++;
            }
    
            System.out.println("count =" + count);
    
            //某屌丝为了追求女神,写了一段代码示爱,但是女神也会java,改动一下把屌丝拒绝
            int j = 1;
            while (j <= 10000) {
                System.out.println("I Love You!!!");
                j++;
            }
        }
    }

2.4 循环结构——do...while语句

• 循环结构do...while语句的格式：

  • 初始化语句;
    do {
    循环体语句;
    控制条件语句;
    }while(判断条件语句);

• 执行流程：

  • 执行初始化语句

  • 执行循环体语句;

  • 执行控制条件语句

  • 执行判断条件语句,看其返回值是true还是false

    • 如果是true，就继续执行

    • 如果是false，就结束循环

  • 回到循环体语句，再次循环，直至控制条件不满足

• 案例演示
  • 需求：请在控制台输出数据1-10

  • class Test {
        public static void main(String[] args) {
            int i = 0;
            do {
                System.out.println(i);
                i++;
            }
            while (i < 11);
        }
    }

2.5 三种循环语句的区别

• 三种循环语句的区别:

• do...while循环至少执行一次循环体。

• 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句

  • 例如：

    • class Demo1_DoWhile {
          public static void main(String[] args) {
              //while 和do while的区别
              int i = 11;
              do {
                  System.out.println("i = " + i);
                  i++;
              }
              while (i <= 10);  // 条件不成立，但是循环体先执行，故至少执行一次循环体
      
              System.out.println("---------------------");
      
              int j = 11;
              while (j <= 10) {
                  System.out.println("j = " + j);
                  j++;
              }  //条件不成立，不执行
      
          }
      }

• • 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。
    • 例如：

      • class Demo1_DoWhile {
            public static void main(String[] args) {
                for (int i = 1;i <= 10 ;i++ ) {
                    System.out.println("i = " + i);
                }
        
                //System.out.println("i = " + i);            for语句执行后变量会被释放,不能再使用
                System.out.println("-------------------");
                int i = 1;
                while (i <= 10) {
                    System.out.println("i = " + i);
                    i++;
                }
                System.out.println("-------------------");
                System.out.println("i = " + i);                //while语句执行后,初始化变量还可以继续使用*/
        
                }
        }

2.6 死循环

• 一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。

• 两种最简单的死循环格式

  • while(true){...}

  • for(;;){...}

  • class Demo1_DoWhile {
        public static void main(String[] args) {
    
            //while语句的无限循环
            while (true) {
                System.out.println("hello world");
            }
    
            //System.out.println("hello world");
            //for语句的无限循环
            for (; ; ) {
                System.out.println("hello world");
            }
        }
    }

2.7 循环嵌套

• 打印4行5列的星星

  • /*
    * A:案例演示
        * 需求：请输出一个4行5列的星星(*)图案。
        *
                如图：
                    *****
                    *****
                    *****
                    *****
    
                注意：
                    System.out.println("*");和System.out.print("*");的区别
    * B:结论：
        * 外循环控制行数，内循环控制列数
    */
    class Demo1_ForFor {
        public static void main(String[] args) {
            /*for (int i = 1;i <= 3 ;i++ ) {                    //外循环
                System.out.println("i = " + i);
                for (int j = 1;j <= 3 ;j++ ) {                //内循环
                    System.out.println("j = " + j);
                }
            }*/
    
            for (int i = 1;i <= 4 ;i++ ) {                    //外循环决定的是行数
                for (int j = 1;j <= 5 ;j++ ) {                //内循环决定的是列数
                    System.out.print("*");
                }
                System.out.println();
            }
        }
    }
    
    /*
    *****
    *****
    *****
    *****
    
    */

  • 结论：
    • 外循环控制行数，内循环控制列数
• 请输出下列的形状

  • /*
    需求：请输出下列的形状
            *
            **
            ***
            ****
            *****
    */
    class Demo2_ForFor {
        public static void main(String[] args) {
            for (int i = 1;i <= 5 ; i++) {                //外循环决定行数
                for (int j = 1;j <= i ;j++ ) {            //内循环决定列数
                    System.out.print("*");
                }
                System.out.println();                    //将光标换到下一行的行首
            }
        }
    }

• 九九乘法表

  • class Test {
        public static void main(String[] args) {
            for (int i = 1;i < 10; i++ ) {
                for (int j = 1; j <= i ; j++ ) {
                    System.out.print(j+"*"+i+"="+(i * j)+" ");
                }
                System.out.println();
    
            }
    
        }
    }

2.8 控制跳转语句——break语句，continue语句，标号，return语句

• break语句
  • 只能在switch和循环中
• continue语句
  • 只能在循环中
• 控制跳转语句标号
  • 标号：标记某个循环对其控制
  • 标号组成规则：其实就是合法的标识符

  • class Demo3_Mark {                                        //mark 标记
        public static void main(String[] args) {
    outer: for (int i = 1;i <= 10 ;i++ ) {        //outer，inner就是标号,只要是合法的标识符即可
                System.out.println("i = " + i);
    inner: for (int j = 1;j <= 10 ;j++ ) {
                    System.out.println("j = " + j);
                    break outer;
                }
            }
        }
    }

  • 标号的格式就是 合法的标识符 加上“:”
    • outer:
    • inner:
    • a:
    • http:
    • this:

• 控制跳转语句return语句)

  • return的作用

    • 返回

      • 其实它的作用不是结束循环的，而是结束方法的。

  • 案例演示

    • return和break以及continue的区别?

      • return是结束方法

      • break是跳出循环

      • continue是终止本次循环继续下次循环