JavaSE笔记02-流程控制、循环控制、Random

• 流程控制语句分类

  • 顺序结构

    • 最简单最基本的控制流程，没有特定的语法结构，按顺序执行
    • 执行顺序：开始→语句A→语句B→语句C→结束
    • 代码示例

    public class OrderDemo {
        public static void main(String[] args) {
            System.out.println("开始"); 
            System.out.println("语句A"); 
            System.out.println("语句B"); 
            System.out.println("语句C");
            System.out.println("结束");  
        }
    }
    

  • 分支结构 if switch

    • if语句1

      • 格式：

      if(关系表达式){
      	语句体;
      }
      

      • 执行流程：
        • 首先计算关系表达式的值
        • 如果关系表达式的值为true，就执行语句体
        • 如果关系表达式的值为false，就不执行语句体
        • 继续执行后面内容
      • 代码示例

      public class IfDeno {
          public static void main(String[] args) {
              System.out.println("开始"); 
              int a = 10;
              int b = 20;
              if(a == b){
                  System.out.println("相等");
              }
              System.out.println("不相等");
      
              int c = 10;
              if(a == c){
                  System.out.println("相等");
              }
              System.out.println("结束");  
          }
      }
      

    • if语句2

      • 格式：

      if(关系表达式){
      	语句体1;
      }else{
      	语句体2;
      }
      

      • 执行流程：
        • 首先计算关系表达式的值
        • 如果关系表达式的值为true，就执行语句体1
        • 如果关系表达式的值为false，就执行语句体2
        • 继续执行后面的内容
      • 代码示例

      public class IfDemo2 {
          public static void main(String[] args) {
              System.out.println("开始"); 
              int a = 10;
              int b = 20;
              if(a > b){
                  System.out.println("a的值大于b");
              }else{
                  System.out.println("a的值不大于b");
              }
              System.out.println("结束"); 
          }
      }
      

    • if案例

      • 奇偶数判断

      import java.util.Scanner;
      public class test3 {
          public static void main(String[] args) {
              Scanner sc = new Scanner(System.in);
              System.out.println("请输入一个数字：");
              int i = sc.nextInt();
              if((i % 2) == 0){
                  System.out.println("输入的数字为偶数");
              }else{
                  System.out.println("输入的数字为奇数");
              }
          }
      }
      

    • if语句3

      • 格式：

      if(关系表达式1){
      	语句体1
      }else if(关系表达式2){
      	语句体2
      }
      ……
      else{
      	语句体n
      }
      

      • 执行流程：
        • 首先计算关系表达式1的值
        • 如果值为true就执行语句体1，如果值为false就计算关系表达式2的值
        • 如果值为true就执行语句体2，如果值为false就计算关系表达式3的值
        • ……
        • 如果没有关系表达式的值为true，就执行语句体n
      • 代码示例

      import java.util.Scanner;
      
      public class IfDemo3 {
          public static void main(String[] args) {
              System.out.println("开始");
              Scanner sc = new Scanner(System.in);
              System.out.println("请输入一个星期（数字1-7）：");
              int i = sc.nextInt();
              if(i == 1){
                  System.out.println("星期一");
              } else if(i == 2){
                  System.out.println("星期二");
              } else if(i == 3){
                  System.out.println("星期三");
              } else if(i == 4){
                  System.out.println("星期四");
              } else if(i == 5){
                  System.out.println("星期五");
              } else if(i == 6){
                  System.out.println("星期六");
              } else if(i == 7){
                  System.out.println("星期七");
              } else {
                  System.out.println("输入错误");  
              }
      
              System.out.println("结束");
              
          }
      }
      

    • switch语句

      • 格式：

      switch(表达式){
      	case 值1:
      					语句体1;
      					break;
      	case 值2:
      					语句体2;
      					break;
      	……
      	default:
      					语句体n;
      					[break;]
      }
      

      • 格式说明：
        • 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String
        • case：后面跟的是要和表达式进行比较的值
        • break：表示中断，结束的意思，用来结束switch语句
        • default：表示所有情况都不匹配的时候，就执行该内容，和if语句的else相似
      • 执行流程
        • 首先计算表达式的值
        • 依次和case后面的值进行比较，如果有对应的值，就执行相应的语句，在执行的过程中，遇到break就结束。
        • 如果所有的case后面的值和表达式都不匹配，就会执行default里面的语句体，然后程序结束
      • 代码示例：

      import java.util.Scanner;
      
      public class SwitchDeno {
          public static void main(String[] args) {
              System.out.println("开始");
              Scanner sc = new Scanner(System.in);
              System.out.println("请输入一个星期（数字1-7）：");
              int i = sc.nextInt();
              switch(i){
                  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控制的语句体后面不写break，将会出现穿透现象，在不判断下一个case的值情况下，向下运行，直到遇到break运行结束。

• 循环语句

  • for循环语句

    • 特征：
      • 重复做某件事
      • 有明确的开始和停止标志
    • 组成：
      • 初始化语句：用于标表示循环开启的起始状态，简答的说就是循环开始的时候什么样。
      • 条件判断语句：用于表示循环反复执行的条件，简单的说就是是否能一直执行下去。
      • 循环体语句：用于表示循环反复执行的内容，简单说就是反复执行的事情。
      • 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
    • 循环结构对应语法：
      • 初始化语句：这里可以是一条或多条语句，完成一些初始化操作
      • 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体
      • 循环体语句：这里可以是任意语句，这些语句将反复执行
      • 条件控制语句：这里通常是使用一条语句改变变量的值，从而达到循环控制是否继续效果。
    • 格式：

    for(初始化语句;条件判断语句;条件控制语句){
    		循环体语句;
    }
    
    死循环格式：（一直执行循环体语句）
    for(;;){
    	循环体语句
    }
    

    • 执行流程
      • 执行初始化语句
      • 执行条件判断语句，结果是true还是false
        • true，继续执行
        • false，结束执行
      • 执行循环体语句
      • 执行条件控制语句
      • 回到第二步继续
    • 代码示例

    public class ForDemo1 {
        public static void main(String[] args) {
            //在控制台输出多次HelloWorld
            for(int i = 1;i < 6;i++){
                System.out.println("HelloWorld");
            }
        }
    }
    

  • while循环语句

    • 格式：

    基本格式：
    while(条件判断语句){
    	循环体语句;
    }
    
    完整格式：
    初始化语句;
    while(条件判断语句){
    	循环体语句;
    	条件控制语句;
    }
    
    死循环格式：
    while(true){
    	循环体语句;
    	条件控制语句;
    }
    

    • 执行流程
      • 执行初始化语句
      • 执行条件判断语句，看起结果是true还是false
        • 如果为false，循环结束
        • 如果为true，继续执行
      • 执行循环体语句
      • 执行条件控制语句
      • 回到第二步继续
    • 代码示例：

    public class WhileDemo1 {
        public static void main(String[] args) {
            //在控制台输出5次HelloWorld
            //for循环实现
            for(int i = 0 ; i <= 5; i++){
                System.out.println("helloworld");
            }
            //while循环实现
            int i = 1;
            while(i<=5){
                System.out.println("HelloWorLD");
                i++;
            }
        }
    }
    

  • do…while循环语句

    • 格式：

    基本格式：
    do{
    	循环体语句;
    }while(条件判断语句);
    
    完整格式：
    初始化语句;
    do{
    	循环体语句;
    	条件控制语句;
    }while(条件判断语句);
    
    死循环格式：
    初始化语句;
    do{
    	循环体语句;
    	条件控制语句;
    }while(true);
    

    • 执行流程
      • 执行初始化语句
      • 执行循环体语句
      • 执行条件控制语句
      • 执行条件判断语句，看结果是true还是false
        • true，继续执行
        • false，循环结束
      • 回到第二步
    • 代码示例：

  • 上述三种循环区别

    • 三种区别
      • for循环和while循环先判断是否成立，然后决定执行循环体
      • do…while循环先执行一次，在判断是否成立
    • for和while
      • 条件控制语句所控制的自增变量，属于for循环结构，在for循环结束后，就不能再访问到
      • 条件控制语句所控制的自增变量，对于while循环，不属于起语法结构，循环结束后仍然可以使用其变量

  • 跳转控制语句

    • 概述：

    - continue用在循环中，基于条件控制，跳过某次循环体内的执行，继续下一次执行。
    - break用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前整个循环
    - 代码示例：

    ```java
    public class ControlDemo {
        public static void main(String[] args) {
            for(int i = 1; i<= 5;i++){
                if(i%2 == 0){
                    // continue;//1  3  5
                    break;//1
                }
                System.out.println(i);
            }
            
        }
    }
    ```

- 循环嵌套
    - 语句顺序：
        - 顺序语句，以分号结尾，表示一句话结束
        - 分支语句
            - 一对大括号表示if整体结构，整体描述一个完整的if语句
            - 一对大括号表示switch整体结构，整体描述一个完整的switch语句
        - 循环语句
            - 一对大括号表示for整体结构，整体描述一个完整的for语句
            - 一对大括号表示while整体结构，整体描述一个完整的while语句
            - do...while以分号结尾，整体描述一个完整的do...while语句

• Random作用和使用步骤

  • 作用，用于产生一个随机数
  • 使用步骤
    • 导包 import java.util.Random;
    • 创建对象 Random r = new Random();
    • 获取随机数 int number = r.nextInt(10);//获取数据范围，[0,10)
  • 代码示例：

  import java.util.Random;
  
  public class RandomDemo {
      public static void main(String[] args) {
          Random r = new Random();
          for(int i = 0; i <10 ; i++){
              int unmber = r.nextInt(10);
              System.out.println(unmber);
          }
          //获取1-100之间的随机数
          int x = r.nextInt(100) + 1;
          System.out.println(x);
  
      }
  }
  

  • 猜数字游戏：

  import java.util.Random;
  import java.util.Scanner;
  
  public class test4 {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          Random r = new Random();
          System.out.println("请输入1-100之间的任意数字：");
          int j = r.nextInt(100) + 1;
          while (true) {
              int i = sc.nextInt();
              if(i > j ){
                  System.out.println("大了");
              }else if(i < j){
                  System.out.println("小了");
              }else {
                  System.out.println("中了");
                  break;
              }
          }
  
      }
  }