狂神说Java（零基础） 流程控制

1.用户交互Scanner

1.1 Scanner对象

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

• 基本语法：

  Scanner s = new Scanner(System.in);

• 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

  package Scanner;
   
  import java.util.Scanner;
   
  public class Demo01 {
      public static void main(String[] args) {
          //创建一个扫描器对象，用于接收键盘数据
          Scanner scanner= new Scanner(System.in);
   
          System.out.println("使用next方式接收：");
   
          //判断用户有没有输入字符串
          //if (scanner.hasNext()==True)
          if (scanner.hasNext()){
              String str = scanner.next();
              System.out.println("输出的内容为："+str);
          }
   
          //凡是属于IO流的类如果不关闭就会一直占用资源，要养成好习惯用完就关掉
          scanner.close();
      }
  }
   
  /*
  输入：hello world
  输出：hello
  */

  package Scanner;
   
  import java.util.Scanner;
   
  public class Demo02 {
      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);
          }
   
          //凡是属于IO流的类如果不关闭就会一直占用资源，要养成好习惯用完就关掉
          scanner.close();
      }
  }
   
  /*
  输入：hello world
  输出：hello world
  */

• next()：

  • 1.一定要读取到有效字符后才可以结束输入；
  • 2.对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  • 3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  • 4.所以next()不能得到带有空格的字符串

• nextLine()：

  • 1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
  • 2.可以获得空白

  package Scanner;
   
  import java.util.Scanner;
   
  public class Demo04 {
      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("输入的不是整数数据！");
          }
      }
  }
   
  /*
  输入：17
  输出：整数数据：17
   
  输入：17.8
  输出：输入的不是整数数据！
  */

• 可以把nextInt()换成nextFloat()试试，相应的，文字部分改"整数"为"小数"。但是程序会存在一定的问题，比如输入12，会输出小数数据：12.0

• 想查看Scanner,就按住Ctrl,然后点击代码里的Scanner,就可以看到一大串内容，然后点击侧边栏的Structure,可以看得更清楚

package Scanner;
 
import java.util.Scanner;
 
public class Demo05 {
    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; //m++
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
        }
 
        System.out.println(m + "个数的和为"+sum);
        System.out.println(m + "个数的平均值是"+(sum / m));
 
        scanner.close();
    }
 
 
}
 
/*
输入：1 2 3 x
输出：
你输入了第1个数据，然后当前结果sum=1.0
你输入了第2个数据，然后当前结果sum=3.0
你输入了第3个数据，然后当前结果sum=6.0
3个数的和为6.0
3个数的平均值是2.0
*/

2.顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照程序一句一句执行

• 顺序结构是最简单的算法结构

• 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

  package struct;
   
  public class ShunXuDemo {
      public static void main(String[] args) {
          System.out.println("hello1");
          System.out.println("hello2");
          System.out.println("hello3");
          System.out.println("hello4");
          System.out.println("hello5");
      }
  }
   
  /*
  输出：
  hello1
  hello2
  hello3
  hello4
  hello5
  */

3.选择结构

• if单选择结构

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

    

  • 语法：

    if (布尔表达式){
        //如果布尔表达式为true将执行的语句
    }

    package struct;
     
    import java.util.Scanner;
     
    public class IfDemo01 {
        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();
        }
    }
     
    /*
    输入：123
    输出：End
     
    输入：Hello
    输出：
    Hello
    End
    */

• if双选择结构

  • 公司要收购一个软件，成功了，给人支付100万元；失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构（图片来源于CSDN）

    

  • 语法：

    if (布尔表达式){
        //如果布尔表达式的值为true
    }else{
        //如果布尔表达式的值为false
    }

    package struct;
     
     
    import java.util.Scanner;
     
    public class IfDemo02 {
        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();
     
        }
     
    }
     
    /*
    输入：50
    输出：不及格
     
    输入：68
    输出：及格
    */

• if多选择结构

  • 我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断。比如90-100就是A，80-90就是B……等等。生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题

  • 语法：

    if (布尔表达式 1){
        //如果布尔表达式 1的值为true执行代码
    }else if (布尔表达式 2){
        //如果布尔表达式 2的值为true执行代码
    }else if (布尔表达式 3){
        //如果布尔表达式 3的值为true执行代码
    }else{
        //如果以上布尔表达式都不为true执行代码
    }

    package struct;
     
    import java.util.Scanner;
     
    public class IfDemo03 {
        public static void main(String[] args) {
            //考试分数大于等于60就是及格，小于60就不及格
            Scanner scanner = new Scanner(System.in);
     
            System.out.println("请输入成绩：");
            int score = scanner.nextInt();
     
            if (score==100){
                System.out.println("恭喜满分");
            }else if (score<100 && 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 && score>=0){
                System.out.println("成绩不合格");
            }else{
                System.out.println("成绩不合法");
            }
     
            scanner.close();
        }
    }
     
    /*
    输入：106
    输出：成绩不合法
     
    输入：58
    输出：成绩不合格
     
    输入：100
    输出：恭喜满分
    */

• 嵌套的if结构

  • 使用嵌套的if…else语句是合法的，也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套 else if…else

  • 语法：

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

  • 思考：我们需要寻找一个数，在1-100之间，该怎么做？——把1-100分成1-50、50-100,即二分法

• switch多选择结构

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

  • switch case语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支

  • switch语句中的变量类型可以是：

    • byte、short、int或者char
    • 从Java SE 7 开始，switch支持字符串String类型了，同时case标签必须为字符串常量或字面量

    switch (expression){
        case value:
            //语句
            break; //可选
        case value:
            //语句
            break; //可选
        //你可以有任意数量的case语句
        default: //可选
            //语句
    }

    package struct;
     
    public class SwitchDemo01 {
        public static void main(String[] args) {
            char grade = 'B';
     
            switch (grade){
                case 'A':
                    System.out.println("优秀");
                    break;
                case 'B':
                    System.out.println("良好");
                    break;
                case 'C':
                    System.out.println("及格");
                    break;
                case 'D':
                    System.out.println("再接再厉");
                    break;
                case 'E':
                    System.out.println("挂科");
                    break;
                default:
                    System.out.println("未知等级");
            }
        }
    }
     
    /*
    输出：良好
    */

  • 如果没有break会怎么样？——会把后面的语句一起输出。

    package struct;
     
    public class SwitchDemo01 {
        public static void main(String[] args) {
            char grade = 'B';
     
            switch (grade){
                case 'A':
                    System.out.println("优秀");
                    break;
                case 'B':
                    System.out.println("良好");
                case 'C':
                    System.out.println("及格");
                case 'D':
                    System.out.println("再接再厉");
                case 'E':
                    System.out.println("挂科");
                default:
                    System.out.println("未知等级");
            }
        }
    }
     
    /*
    输出：
    良好
    及格
    再接再厉
    挂科
    未知等级
    */

4.循环结构

4.1 while循环

• while循环是最基本的循环，它的结构为：

  while (布尔表达式){
      //循环内容
  }

• 只要布尔表达式为true，循环就会一直执行下去。我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环

  package struct;
   
  public class WhileDemo01 {
      public static void main(String[] args) {
          //输出1-100
   
          int i = 0;
   
          while (i<100){
              i++;
              System.out.println(i);
          }
      }
  }
   

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

  package struct;
   
  public class WhileDemo02 {
      public static void main(String[] args) {
          //死循环
          while (true){
              //等待客户端连接
              //定时检查
              //……
          }
      }
  }	

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

• 思考：计算1+2+3+…+100=？

  package struct;
   
  public class WhileDemo03 {
      public static void main(String[] args) {
          //计算1+2+3+…+100=？
          int i = 0;
          int sum = 0;
   
          while (i<=100){
              sum = sum + i;
              i++;
          }
          System.out.println(sum);
      }
   
  }
   
  /*
  输出：
  5050
  */

4.2 do…while循环

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

• do…while循环和while循环相似，不同的是，do…while循环至少会执行一次

  do {
      //代码语句
  }while (布尔表达式);

• while和do-while的区别：

  • while先判断后执行。do-while是先执行后判断

    package struct;
     
    public class DoWhileDemo01 {
        public static void main(String[] args) {
            int i = 0;
            int sum = 0;
     
            do {
                sum = sum+i;
                i++;
            }while (i <= 100);
     
            System.out.println(sum);
        }
    }
     
    /*
    输出：
    5050
    */

  • do-while总是保证循环体会被至少执行一次。这是它们的主要差别

    package struct;
     
    public class DoWhileDemo02 {
        public static void main(String[] args) {
            int a = 0;
            while (a<0){
                System.out.println(a);
                a++;
            }
            System.out.println("=================");
            do {
                System.out.println(a);
                a++;
            }while (a<0);
        }
    }
     
    /*
    输出：
    =================
    0
    */

4.3 for循环

• 在Java5中引入了一种主要用于数组的增强for循环

• 虽然所有循环结构都可以用while或者do-while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环执行的次数是在执行前就确定的。语法格式如下：

  for (初始化;布尔表达式;更新){
      //代码语句
  }		

package struct;
 
public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1; //初始化条件
 
        while (a <= 100){   //条件判断
            System.out.println(a);    //循环体
            a += 2;   //迭代
        }
        System.out.println("while循环结束！");
 
        //初始化//条件判断//迭代
        for (int i = 1;i <= 100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束! ");
    }
}
	

• IDEA快捷方式：在main方法中输入100.for，回车，会自动生成：

  for (int i = 0; i < 100; i++) {
              
  }

• 关于for循环有以下几点说明：

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
  • 然后，检测布尔表达式的值。如果为true，循环体被执行；如果为false，循环终止，开始执行循环体后面的语句
  • 执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)
  • 再次检测布尔表达式，循环执行上面的过程

  //死循环
  for ( ; ; ){
      
  }

• 练习：

  • 练习1：计算0到100之间的奇数和偶数的和

    package struct;
     
    public class ForDemo02 {
        //-练习1：计算0到100之间的奇数和偶数的和
        public static void main(String[] args) {
            int oddSum = 0;
            int evenSum = 0;
     
            for (int i = 0; i <= 100; i++) {
                if (i % 2 != 0){   //奇数
                    oddSum += i;   //oddSum = oddSum +i;
                }else{    //偶数
                    evenSum += i;
                }
            }
            System.out.println("奇数的和："+oddSum);
            System.out.println("偶数的和："+evenSum);
        }
    }
     
    /*
    输出:
    奇数的和：2500
    偶数的和：2550
    */

  • 练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

    package struct;
     
    public class ForDemo03 {
        //练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        public static void main(String[] args) {
            for (int i = 0; i <= 1000; i++) {
                if (i%5==0){
                    System.out.println(i+"\t");
                }
                if (i%(5*3)==0){
                    //System.out.println();
                    System.out.print("\n");
     
                    //println输出完，会换行
                    //print输出完，不会换行
                }
            }
        }
    }
     

  • 练习3：打印九九乘法表

    ackage struct;
     
    public class ForDemo04 {
        public static void main(String[] args) {
            for (int j = 1; j <= 9; j++) {
                for (int i = 1; i <= j; i++) {
                    System.out.print(i+"*"+j+"="+(j*i)+"\t");
                }
                System.out.println();
            }
        }
    }
     
    /*
    输出：
    1*1=1	
    1*2=2	2*2=4	
    1*3=3	2*3=6	3*3=9	
    1*4=4	2*4=8	3*4=12	4*4=16	
    1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
    1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
    1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
    1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
    1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
    */

4.4 增强for循环

• 这里我们先只是见一面，做个了解，之后数组我们重点使用

• Java5引入了一种用于数组或集合的增强型for循环。Java增强for循环语法格式如下：

  for (声明语句 ： 表达式)
  {
      //代码句子
  }

package struct;
 
public class ForDemo05 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50};
 
        for (int i = 0; i < 5; i++){
            System.out.println(numbers[i]);
        }
        System.out.println("==================");
        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}
 
/*
输出：
10
20
30
40
50
==================
10
20
30
40
50
*/

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法

5.break&continue

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

  package struct;
   
  //输出1-30
  public class BreakDemo {
      public static void main(String[] args) {
          int i = 0;
          while (i < 100){
              i++;
              System.out.println(i);
              if (i == 30){
                  break;
              }
          }
      }
  }
   

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

  package struct;
   
  public class ContinueDemo {
      public static void main(String[] args) {
          int i = 0;
          while (i < 100){
              i++;
              if (i % 10 == 0){
                  System.out.println();
                  continue;
              }
              System.out.println(i);
          }
      }
  }
   
  /*
  输出：
  1
  2
  3
  4
  5
  6
  7
  8
  9
   
  11
  12
  13
  14
  15
  16
  17
  18
  19
   
  21
  22
  23
  24
  25
  26
  27
  28
  29
   
  31
  32
  33
  34
  35
  36
  37
  38
  39
   
  41
  42
  43
  44
  45
  46
  47
  48
  49
   
  51
  52
  53
  54
  55
  56
  57
  58
  59
   
  61
  62
  63
  64
  65
  66
  67
  68
  69
   
  71
  72
  73
  74
  75
  76
  77
  78
  79
   
  81
  82
  83
  84
  85
  86
  87
  88
  89
   
  91
  92
  93
  94
  95
  96
  97
  98
  99
   
  */

• 关于goto关键字

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

  • "标签"是指后面跟一个冒号的标识符，例如：label：

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

    package struct;
     
    public class LabelDemo {
        //打印101-150之间的所有质数
        //质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数
        public static void main(String[] args) {
            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+" ");
            }
        }
    }
     
    /*
    输出：
    101 103 107 109 113 127 131 137 139 149 
    */

6.练习

• 打印三角形

  package struct;
   
  public class TestDemo {
      public static void main(String[] args) {
          //打印三角形 5行
          for (int i = 1; i <= 5; i++) {
              for (int j = 5; j >= i ; j--){
                  System.out.print(" ");
              }
              for (int j =1; j <=i ; j++){
                  System.out.print("*");
              }
              for (int j =1; j <i ; j++){
                  System.out.print("*");
              }
              System.out.println();
          }
      }
  }
   
  /*
  输出：
       *
      ***
     *****
    *******
   *********
  */