Day4 | Java流程控制

一、用户交互Scanner

  1. 之前学习的基本语法中并没有实现程序和人的交互,但是Java提供了这样一个工具类,可以获取用户的输入。java.util.Scanner是Java5的新特征,可以通过Scanner类来获取用户的输入。

  2. 基本语法:

    Scanner s = new Scanner(System.in);
    
  3. 通过Scanner类的next()与nextLine()方法获取输入的字符串,在获取前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

    (1) next()

    • 一定要读取到有效字符后才可以结束输入
    • 对输入有效字符之前遇到的空白,next()方法会自动将其去掉
    • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
    • next()不能得到带有空格的字符串
    public static void main(String[] args){
            // 创建一个扫描器对象,用于接收键盘数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("使用next方式接收:");
            // 判断用户有没有输入字符串
            if (scanner.hasNext()){
                // 使用Next方式接收
                String str = scanner.next();
                System.out.println("输出的内容为:"+str);
            }
    
            // 凡是属于IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关闭
            scanner.close();
        }
    
    

    在这里插入图片描述

    (2) nextLine()

    • 以Enter为结束符,也就是说,nextLine()方法返回的是输入回车之前的所有字符
    • 可以获得空白
    public static void main(String[] args){
            // 从键盘接收数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("使用nextLine方式接收:");
            // 判断是否还有输入
            if(scanner.hasNextLine()){
                String str = scanner.nextLine();
                System.out.println("输出的内容为:"+str);
            }
            scanner.close();
        }
    

    在这里插入图片描述

    // 常用的是nextLine(),总体的格式如下
    public static void main(String[] args) {
            // 从键盘接收数据
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入数据:");
            String str = scanner.nextLine();
            System.out.println("输出的内容为:" + str);
            scanner.close();
        }
    
    // 下面是一个输出整数和小数的例子
    public static void main(String[] args){
            Scanner scanner = new Scanner(System.in);
    
            int i = 0;
            float f = 0.0f;
    
            // 输出整数
            System.out.println("请输入整数:");
            if (scanner.hasNextInt()){
                i = scanner.nextInt();
                System.out.println("整数数据:" + i);
            }else{
                System.out.println("输入的不是整数数据!");
            }
    
            // 输出小数
            System.out.println("请输入小数:");
            if (scanner.hasNextFloat()){
                f = scanner.nextFloat();
                System.out.println("小数数据:" + f);
            }else{
                System.out.println("输入的不是小数数据!");
            }
        }
    
    // 下面是一个输入并执行计算的例子
    public static void main(String[] args){
            // 可以输入多个数字,并求其总和与平均数,每输入一个数字用回车确认,通过输入非数字来结束输入并输出执行结果
            Scanner scanner = new Scanner(System.in);
            // 和值初始化
            double sum = 0;
            // 计算输入了多少个数字
            int m = 0;
            // 通过循环判断是否还有输入,并在里面对每一次进行求和与统计
            while (scanner.hasNextDouble()){
                double x = scanner.nextDouble();
                m = m + 1;
                sum = sum + x;
                System.out.println("你输入了第" + m + "个数据,然后当前结果sum=" + sum);
            }
            System.out.println(m + "个数的和为:" + sum);
            System.out.println(m + "个数的平均值是" + (sum / m));
    
            scanner.close();
        }
    

    在这里插入图片描述

    // 下面也是一个计算总和和平均值的例子,是自己练习的,与上面的代码一样,输入除数字以外的值则停止运行
    public static void main(String[] args){
            Scanner scanner = new Scanner(System.in);
            // 用于循环的变量i
            int i = 1;
            double sum = 0.0;
            System.out.println("请输入:");
            while(scanner.hasNextDouble()){
                double x = scanner.nextDouble();
                sum = sum + x;
                System.out.println("输入的第" + i + "个数为:" + x + ";此时的和为:" + sum + ",平均值为:" + (sum/i));
                i = i + 1;
                System.out.println("\n请输入:");
            }
            scanner.close();
        }
    

    在这里插入图片描述

二、顺序结构

  1. Java的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行
  2. 顺序结构是最简单的算法结构
  3. 语句与语句之间,框与框之间都是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构
// 顺序结构:一条一条语句按顺序执行
    public static void main(String[] args){
        System.out.println("A");
        System.out.println("B");
        System.out.println("C");
        System.out.println("D");
        System.out.println("E");
    }

在这里插入图片描述

三、if 选择结构

  1. if单选择结构

    • 很多时候需要去评判一个东西是否可行,然后才会去执行,这样一个过程在程序中用if语句来表示

在这里插入图片描述

  • 语法:

    if (布尔表达式){
       // 如果布尔表达式为true执行语句
    }
    
    public static void main(String[] args){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入内容:");
            String s = scanner.nextLine();
            // equals:判断字符串是否相等
            if (s.equals("Hello")){
                System.out.println(s);
            }
            System.out.println("End");
            scanner.close();
        }
    

    在这里插入图片描述
    在这里插入图片描述

  1. if 双选择结构

    • if - else 结构

在这里插入图片描述

  • 语法

    if (布尔表达式){
        // 如果布尔表达式的值为true
    } else {
        // 如果布尔表达式的值为false
    }
    
    public static void main(String[] args){
            // 输入一个分数,小于60分为不及格,大于60分为及格
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个成绩:");
            int score = scanner.nextInt();
            if (score>60){
                System.out.println("及格");
            } else {
                System.out.println("不及格");
            }
            scanner.close();
        }
    

    在这里插入图片描述
    在这里插入图片描述

    1. if 多选择结构

      • 真实的情况还可能存在区间多级判断,例如成绩有优、良、中、差,在生活中很多时候的选择也不仅仅只有两个,所以还需要一个多选择结构来处理这个问题

      在这里插入图片描述

      • 语法

        if (布尔表达式1){
            // 如果布尔表达式1的值为true执行代码
        } else if (布尔表达式2){
            // 如果布尔表达式2的值为true执行代码
        } else if (布尔表达式3){
            // 如果布尔表达式3的值为true执行代码
        } else {
            // 如果以上布尔表达式都不为true执行代码
        }
        
        public static void main(String[] args){
                /*
             输入一个成绩: score>=90 为A级
                         80<=score<90 为B级
                         70<=score<80 为C级
                         60<=score<70 为D级
                         0<=score<60 为不及格
                         score<0 为不合法的成绩
             */
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入一个成绩:");
                int score = scanner.nextInt();
                if (score>=90){
                    System.out.println("A级");
                } else if (score<90 && score>=80) {
                    System.out.println("B级");
                } else if (score<80 && score>=70) {
                    System.out.println("C级");
                } else if (score<70 && score>=60) {
                    System.out.println("D级");
                } else if (score<60) {
                    System.out.println("成绩不及格");
                } else {
                    System.out.println("成绩不合法!");
                }     
                scanner.close();
            }
        
      • 注意:if 语句至多有1个 else 语句,else 语句在所有 else if 语句之后

        ​ if 语句可以有若干个 else if 语句,但是它们必须在 else 语句之前

        ​ 一旦其中一个 else if 语句检测为true,其他的 else if 以及 else 语句都将跳过执行

    2. 嵌套的 if 结构

      • 语法

        if (布尔表达式1){
            // 如果布尔表达式1的值为true执行代码
            if (布尔表达式2){
                // 如果布尔表达式2的值为true执行代码
            }
        }
        

四、Switch选择结构

  1. 多选择结构还有一个实现方式就是switch case语句

    switch (expression) {
        case value:
            // 语句
            break;   // 可选
        case value:
            // 语句
            break;   // 可选
        // 你可以有任意数量的case语句
        default:   // 可选
            // 语句
    }
    
  2. switch case语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支

    public static void main(String[] args){
            // switch匹配一个具体的值
            // 输入一个成绩,匹配该成绩的等级
            // 每一个case语句里面如果不加上break,将会执行后面的所有case语句,称为穿透现象
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个成绩:");
            int score = scanner.nextInt();
            int n = score / 10;
            switch (n){
                case 0:
                case 1:
                case 2:
                case 4:
                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:
                case 10:
                    System.out.println("优秀!");
                    break;
                default:
                    System.out.println("输入不合法!");
            }
            scanner.close();
        }
    
  3. switch语句中变量类型可以是:

    • byte、short、int或者char
    • 从Java SE 7开始
    • switch支持字符串String类型了
    • 同时case标签必须为字符串常量或字面量
    public static void main(String[] args){
            // JDK7的新特性,表达式结果可以是字符串
            // 字符的本质还是数字
            // 反编译   java---class(这是字节码文件)----反编译(IDEA就可以实现)
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个词:");
            String word = scanner.nextLine();
            switch (word){
                case "世界":
                    System.out.println("世界");
                    break;
                case "狂神":
                    System.out.println("狂神");
                    break;
                default:
                    System.out.println("出错!");
            }
        }
    

    可以看到文件夹下的class文件,但是打开看到是乱码,可以利用IDEA打开文件夹查看

    在这里插入图片描述

打开之后有一个问题,还是没太弄懂:为什么我打开了class文件之后,反编译还是和java文件发编码是一样的,并没有出现像狂神课上显示的那种?

在这里插入图片描述

在这里插入图片描述

五、循环结构

  1. while循环

    • while是最基本的循环,它的结构为:

      while (布尔表达式) {
          // 循环内容
      }
      
    • 只要布尔表达式为true,循环就会一直执行下去

    • 我们大多数情况下是会让循环结构停下来的,这就需要一个让表达式失效的方式来结束循环

    • 少部分情况需要循环一直执行,比如服务器的请求响应监听等

    • 循环条件一直为true就会造成无限循环【死循环】,正常的业务编程中应该尽量避免死循环,会影响程序性能或者造成程序卡死崩溃

      public static void main(String[] args){
              // 计算1+2+3+4+...+100
              int i = 1;
              int sum = 0;
              while (i <= 100){
                  sum = sum + i;
                  i++;
              }
              System.out.println("1~100的总和为:" + sum);
          }
      
  2. do…while 循环

    • 对于while语句而言,如果不满足条件,则不能进入循环,但是有时候我们需要即使不满足条件,也能执行一次

    • do…while 循环与while循环相似,不同的是do…while 循环至少会执行一次,它的结构为:

      do {
          // 代码语句
      } while (布尔表达式);
      
    • while循环与do…while 循环的区别:

      while循环先判断后执行,do…while 循环是先执行后判断

      do…while 循环总是保证循环体会被至少执行一次,这是他们的最主要差别

      public static void main(String[] args){
              int a = 0;
              System.out.println("使用while循环输出:");
              while (a<0){
                  System.out.println(a);
                  a++;
              }
              System.out.println("\n使用while循环输出:");
              do {
                  System.out.println(a);
                  a++;
              } while (a<0);
          }
      

      在这里插入图片描述

  3. for 循环

    • 虽然所有循环结构都可以用while或者do…while 表示,但是Java提供了另一种语句–for循环,使一些循环结构变得更加简单

    • for 循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构

    • for 循环执行的次数是在执行前就确定的,语法格式如下:

      for (初始化;布尔表达式;更新){
          // 代码语句
      }
      
      /*
          关于for循环的几点说明:
              最先执行初始化步骤,可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句;
              然后检测布尔表达式的值,如果为true,循环体被执行,如果为false,循环终止,开始执行循环体后面的语句;
              执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减);
              再次检测布尔表达式,循环执行上面的过程。
           */
          public static void main(String[] args){
              // 对于while循环
              int a = 1;    // 初始化条件
              while (a<=10){    // 条件判断
                  System.out.println(a);    // 循环体
                  a += 1;    // 迭代
              }
              System.out.println("while循环结束!");
      
              // 对于for循环
              // 初始化 条件判断 迭代
              for (int i=1;i<=10;i++){
                  System.out.println(i);
              }
              System.out.println("for循环结束!");
          }
      

      在这里插入图片描述

    • 练习

      // 计算0到100之间奇数和偶数的和
      public static void main(String[] args){
              // 计算0到100之间的奇数和偶数的和
              int oddSum = 0;
              int evenSum = 0;
              for (int i = 0; i < 100; i++) {
                  if (i%2 == 0) {
                      oddSum += i;   // 偶数和
                  }else {
                      evenSum += i;   // 奇数和
                  }
              }
              System.out.println("偶数的和为:" + oddSum);
              System.out.println("奇数的和为:" + evenSum);
          }
      
      // 用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个
      public static void main(String[] args){
              // 输出1-1000之间能被5整除的数,并且每行输出3个
              for (int i = 0; i <= 1000; i++) {
                  if (i%5 == 0){
                      System.out.print(i+"\t");
                  }
                  if (i%(5*3)==0){   // 这里就是保证每行输出3个被5整除的数
                      // println 输出完会换行
                      // print 输出完不会换行
                      System.out.println();
                      // System.out.print("\n");
                  }
              }
          }
      

      在这里插入图片描述

      // 打印九九乘法表
      public static void main(String[] args){
              // 输出九九乘法表
              /*
              思路(也就是把大问题拆分为小问题):
                 1.先打印第一列
                 2.把固定的1再用一个循环包起来,就是每列那个
                 3.去掉重复项,也就是在内层循环把j<10改为j<i就可以
                 4.调整样式
               */
              for (int i = 1; i < 10; i++) {
                  for (int j = 1; j < i; j++) {
                      System.out.print(j + "*" + i + "=" + (j*i) + "\t");
                  }
                  System.out.println();
              }
          }
      

      在这里插入图片描述

  4. 增强 for 循环

    • 这里只是简单做个了解,之后在数组部分会做重点使用

    • Java5引入了一种主要用于数组或集合的增强型for循环

    • Java增强for循环语法格式如下:

      for (声明语句:表达式)
      {
          // 代码句子
      }
      
    • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配,其作用域限定在循环语句块,其值与此时数组元素的值相等

    • 表达式:表达式是要访问的数组名,或者是返回值为数组的方法

      public static void main(String[] args){
              int[] numbers = {10, 20, 30, 40, 50};   //定义了一个数组
              // 普通for循环遍历数组的元素
              for (int i=0; i<5; i++){
                  System.out.println(numbers[i]);
              }
      
              // 增强for循环遍历数组的元素
              System.out.println("-----------------");
              for (int x:numbers){
                  System.out.println(x);
              }
          }
      

      在这里插入图片描述

  5. break与continue

    • break在任何循环语句的主体部分,均可用break控制循环的流程,break用于强行退出循环,不执行循环中剩余的语句(break语句也在switch语句中使用)

      public static void main(String[] args){
              int i = 0;
              while (i<5) {
                  i++;
                  System.out.println(i);
                  if (i==3){
                      break;    // 就是当i等于3的时候,循环就结束了,跳出while循环,但是继续执行while这个循环语句后面的内容
                  }
              }
              System.out.println("循环结束");
          }
      

      在这里插入图片描述

    • continue语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定

      public static void main(String[] args){
              int i = 0;
              while (i<10){
                  i++;
                  if (i%5 == 0){
                      System.out.println();
                      continue;    // 只会停止执行i%5等于0的情况,然后进行下一次循环,这次的continue并没有影响之后的while循环的执行
                  }
                  System.out.println(i);   // 也就是遇到5和10是不会输出的
              }
              System.out.println("循环结束!");
          }
      

      在这里插入图片描述

  6. 关于 goto 关键字

    • goto关键字很早就在程序设计语言中出现,尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用:Java没有goto,然而在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子—带标签的break和continue

    • “标签”是指后面跟一个冒号的标识符,例如:label

    • 对Java来说唯一用到标签的地方是在循环语句之前,而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环,由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方

      public static void main(String[] args){
              // 打印101 - 150之间的质数
              int count = 0;
              // 这个内容写起来十分麻烦,不建议使用
              outer:for (int i = 101;i<=150;i++){
                  for (int j = 2;j<i/2;j++){
                      if (i % j == 0){
                          continue outer;
                      }
                  }
                  System.out.print(i + "  ");
              }
      
          }
      
    1. 练习

      • 打印三角形

         public static void main(String[] args){
                // 打印三角形 6行
                // 外层循环就是控制输出8行
                for (int i = 1; i<=8; i++){
                    // 第一个内层循环用来打印整个三角形左边的空格
                    for (int j = 8; j>=i; j--){
                        System.out.print(" ");
                    }
                    // 第二个内层循环用来打印三角形左边小直角三角形的部分
                    for (int j = 1; j<=i; j++){
                        System.out.print("*");
                    }
                    // 第三个内层循环用来打印三角形右边小直角三角形的部分
                    for (int j = 1; j<i; j++){   // 因为第二个内层循环已经打印了三角形的顶点,所以这个内层循环不用再打印顶点,故j<i,去掉=i的情况
                        System.out.print("*");
                    }
                    System.out.println();
                }
            }
        

        在这里插入图片描述

        • debug

          在这里插入图片描述


          注:资料来源参考遇见狂神说的课程[https://www.bilibili.com/video/BV12J41137hu/?spm_id_from=333.999.0.0&vd_source=51e338bc66714d1cb8adb07196bec5e5]

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值