Java基础—分支和循环

分支

        程序执行过程中，有可能需要根据不同的结果执行不同的操作，该现象称之为分支结构。

if分支

        语法：

if(布尔表达式){
    //操作语句
}

example：
//判断成绩，如果成绩为100，则输出“你真棒！”,否则不做任何操作
        //定义变量，表示成绩
        int score=99;
        //判断成绩
        if (score == 100) {
            System.out.println("你真棒！");
        }

        特点：只有满足if条件才会执行内部操作语句。

if-else分支

        语法：

if(布尔表达式){
    //if中操作语句
}else{
    //else中的操作语句
}

example：

//判断成绩，如果成绩>=60,则输出“及格”，否则输出“不及格”
        int score=59;//成绩
        if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }

        特点：一定且只会执行其中一个操作语句。 

多重if分支

        语法：

if(布尔表达式1){
    //操作语句1
}else if(布尔表达式2){
    //操作语句2
}else{
    //else中的操作语句
}

example：

//判断成绩
        /*如果成绩==100,输出满分
        如果成绩>=80,输出优秀
        如果成绩>=60,输出及格
        否则输出不及格
        * */
        int score=50;//成绩

        if (score == 100) {
            System.out.println("满分");
        } else if (score >= 80) {
            System.out.println("优秀");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }

         特点：自上而下进行判断，当执行到某个满足的分支时，剩余分支将不再执行。最多执行一个操作语句，只要逻辑完整，else-if的数量不做具体要求。else部分可以省略（但为了保证分支的完整性，通常不会省略）。

嵌套分支

        语法：

if(外层布尔表达式){
    if(内层布尔表达式1){
        //内层if操作语句
    }
}else{
    if(内层布尔表达式2){
        //内层if操作语句
    }
}

example： 

//判断成绩
        /*如果成绩==100,输出满分
        如果成绩>=80,输出优秀
        如果成绩>=60,输出及格
        否则不及格,再次判断成绩是否>=50,输出“继续努力”,否则输出“重头再来”
        * */
        int score=40;//成绩

        if (score == 100) {
            System.out.println("满分");
        } else if (score >= 80) {
            System.out.println("优秀");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
           // System.out.println("不及格");
            //判断成绩是否>=50
            if (score >= 50) {
                System.out.println("继续努力");
            }else{
                System.out.println("重头再来");
            }
        }

        特点：只要逻辑完整，对嵌套分支、嵌套类型、嵌套层数不做具体要求。 

switch分支

        语法：

switch(变量|拥有具体值结果的表达式){
    case 值1:  //if(变量 == 值1)
        //操作语句1
        break;
    case 值2: //if(变量 == 值2)
        //操作语句2
        break;
    ...
    default: //else
        //default中的操作语句
}

        特点：只适用于等值判断/有具体值的表达式。case自上而下判断，当所有case都不满足时，才会执行default。break的作用为强制结束分支剩余内容的执行，因为当某个case满足条件时，剩余的case将不再进行判断，程序会继续执行，所有分支的代码块会全部执行。最后一个语句块不需要添加break，因为其执行结束后Switch会自然停止。多个case可以共同使用同一个操作语句。 所有switch分支能够实现的操作if分支一定可以实现，但反之则不一定（如：区间判断）。switch只能判断byte、char、short、int、string类型。 

        案例一：

//模拟程序，接收用户输入，
        /*
        数字1，输出“添加”
        数字2,输出“删除”
        数字3，输出“修改”
        数字4，输出“查询”
        否则，输出“未知操作”
        * */
        //创建扫描器
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个操作数字：");
        int n = sc.nextInt();
        //判断用户输入
        switch (n){
            case 1://if(n == 1)
                System.out.println("添加");
                break;
            case 2://if(n == 2)
                System.out.println("删除");
                break;
            case 3://if(n == 3)
                System.out.println("修改");
                break;
            case 4://if(n == 4)
                System.out.println("查询");
                break;
            default://else
                System.out.println("未知操作！");
        }

        案例二： 

//定义变量表示月份，判断月份，输出天数
        //闰年：
        /*1. 能被4整除但是不能被100整除
        2. 能被400整除
        * */
        int year=2001;//年份
        int month=2;//月份
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7://if(month==1 || month==3 || month==5 || month==7)
            case 8:
            case 10:
            case 12:
                System.out.println("31天");
                break;
            case 4:
            case 6://if(month==4 || month==6)
            case 9:
            case 11:
                System.out.println("30天");
                break;
            case 2:
                //判断是否是闰年
                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                    //是闰年
                    System.out.println("29天");
                } else {
                    System.out.println("28天");
                }
                break;
            default:
                System.out.println("我不知道");
        }

局部变量

        定义：局部变量为定义在方法内的变量。

        作用范围：从定义行开始至直属代码块{}结束。

        命名冲突：在同一作用范围内不可重名。

public static void main(String[] args) {
        int n=10;//作用范围为该行开始至main函数结束
        
        if(true){
            int a=20;//作用范围只在if分支内
            //int n=30; 错误！
            //int a=30; 错误！
            System.out.println(n);
        }else{
            int a=30;//作用范围只在else分支内
        }

        System.out.println(n);
        //System.out.println(a); 报错！找不到变量，因为两个a的作用范围只在自身所在分支。
        
    }

循环

可以使操作语句在满足某个条件的前提下同时执行多次，解决代码冗余问题。

for循环

        语法：先判断，再执行操作语句，最后进行迭代，执行次数0-n次。

        名词解释：

                循环初始值：从几开始循环；循环条件：在哪个范围内可以继续循环；迭代语句：对循环初始值进行有规律的变化。

for(循环初始值;循环条件;迭代语句){
    //操作语句
}

example：

//1. 计算1-100的和
        // 1+2+3+4+5+6+7+8+9...+100
      int sum=0;//累加器，接收数字之和,写在循环上方
        for(int i=1;i<=100;i++){
            //将i的值加给sum
            sum+=i;//0+1+2+3+4+5..+100
        }

        System.out.println(sum);

while循环

        语法：

while(循环条件-布尔表达式){
    //操作语句
}

example：

//有一条路，总长80米，小明一步0.9米，问：多少步可以把路走完
        int i=0;//步数
        double num=0;//米数
        while(num<80){//循环条件：米数<80，继续前进
            i++;//步数+1
            num+=0.9;//米数+0.9
        }

        System.out.println(i+"步可以将路走完");

while的特点

        先判断，再执行，最后迭代，执行次数0-n次。

while循环和for循环的区别

1.  for循环适用于循环次数和范围不确定的情况。
2.  while循环适用于循环次数和范围不确定的情况。      

流程控制关键字

        流程控制关键字可以再循环执行过程中改变循环的执行流程。

break

        作用：跳出所有循环，使当前循环停止。在死循环+break（条件跳出）很常见。

        （死循环：当条件永远满足时，操作语句可以一直执行，形成死循环。）

//有一条路，总长80米，小明一步0.9米，问：多少步可以把路走完
  int i=0;//步数
  double num=0;//米数

  while(true){
      i++;//步数+1
      num+=0.9;//米数+0.9
      //判断米数是否到达80
      if(num>=80){
          break;//使循环停止
      }
  }

  System.out.println(i+"步可以将路走完");

continue

        作用：跳出本次循环，开始下一次循环。

        //书写1-10的循环，跳过偶数的输出
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            System.out.println(i);
        }

break和continue的区别

        1. 作用不同：break是停止所有循环，而continue为停止本次循环开始下一次循环。

        2. 应用场景不同：break可以作用于switch分支和循环，continue只能作用于循环。

do-while循环

        语法：

do{
     //操作语句
}while(循环条件);

example：

 //需求：张三跑圈，每跑完一圈对其打分，直到分数>=80才能停止跑圈
        //创建扫描器
        Scanner sc = new Scanner(System.in);

        do{
            System.out.println("张三正在跑圈...");
            System.out.println("跑圈结束，为其打分：");
            //接收用户输入
            int score = sc.nextInt();
            //判断分数是否>=80
            if (score >= 80) {
                break;//结束执行
            }
        }while(true);

特点

        先执行，在判断。执行次数1-n次。

while循环和do-while的区别

        1. while先判断再执行，执行次数为0-n次。

        2. do-while先执行再判断，执行次数为1-n次。

嵌套循环

        使用特点：

                1. 图形输出：外层循环代表行，内层循环代表列。

                2. 执行流程：外层循环执行一次，内层循环执行一遍。

                3. break和continue只能作用于直属的循环层次。

                4. 只要逻辑完整，嵌套层数不做要求，但是通常不超过两层（层数过多会影响性能）

重点掌握

1. if分支系列的使用

2. switch能够判断的数据类型

3. 局部变量的概念、作用范围、命名冲突

4. 三个循环结构的使用

5. break和continue的区别

6. 嵌套循环的执行流程