Java分支和循环结构详解/while/do while /for循环详解/死循环/Random用法

程序三种执行顺序

分支结构：if分支结构三种写法及细节、switch分支点执行流程、switch三大注意事项、case穿透；

循环结构：while、do while、for循环的结构、死循环写法、九九乘法表、for循环嵌套结构、猜数字游戏

程序流程控制

控制程序的执行顺序

程序的执行顺序有什么?

经典的三种执行顺序：顺序、分支、循环。

• 顺序结构

自上而下的执行代码

• 分支结构

根据条件，选择对应代码执行

if、switch

• 循环结构

控制某段代码重复执行

for、while、do while循环

---

if分支结构三种

根据条件（真或假）来决定执行某段代码。

体温检测、银行卡余额判断

第一种if

如果条件不成立，什么也不干

//第一种写法，只有真的判断条件和结果，否则没有执行
        if(t>37.3){
            System.out.println("你发烧了");
        }

记住这里（）后面不要加分号，否则成代码块了

[重点]省略{}写法

if(t>37)
    System.out.println("你发烧了");

只有一行的时候，可以这么写，也能正常执行。

第二种if else

成立和不成立必然执行一种情况。

package com.itheima.branch;
​
public class IfDemo01 {
    public static void main(String[] args) {
        double t = 37.5;
//第一种写法，只有真的判断条件和结果，否则没有执行
        if(t>37.3){
            System.out.println("你发烧了");
        }
        //否则什么也不执行
//第二种写法，必然有是和否的结果。
        double money = 510;
        if(money >= 520){
            System.out.println("宝贝给你发了个大红包");
        }
        else{
            System.out.println("555，真没钱了");
        }
​
    }
}
​

[重点]第三种if else if

末尾不写else情况

如果每个条件都为false，那么都不执行，什么都不输出。

• 代码：

  public class IfDemo02 {
      public static void main(String[] args) {
          double score = 268.5;
          if(score>=90 && score<=100){
              System.out.println("你的绩效等级是 A");
          }else if(score>=80 && score<=90){
              System.out.println("你的绩效等级是 B");
          }else if(score>=70 && score<=80){
              System.out.println("你的绩效等级是 C");
          }
      }
  }

末尾写else情况

public class IfDemo02 {
    public static void main(String[] args) {
        double score = 268.5;
        if(score>=90 && score<=100){
            System.out.println("你的绩效等级是 A");
        }else if(score>=80 && score<=90){
            System.out.println("你的绩效等级是 B");
        }else if(score>=70 && score<=80){
            System.out.println("你的绩效等级是 C");
        }else {
            System.out.println("你输入的绩效分数有问题");
        }
    }
}
//输出
//"你输入的绩效分数有问题"

Switch

• 是通过比较值来决定执行哪条分支

[重点]switch分支的执行流程

1.先执行表达式的值，再拿着这个值去与case后的值进行匹配。 2.与哪个case后的值匹配为true就执行哪个case块的代码，遇到break就跳出switch分支。 3.如果全部case后的值与之匹配都是false,则执行default块的代码。

• 如果没有default，且与每个case匹配都是false，则什么都不执行。

代码

public class SwitchDemo02 {
    public static void main(String[] args) {
        //switch能干的if都能干
        String week = "周一";
        switch (week){
            case "周一":
                System.out.println("埋头苦干。解决bug");
                break;
            case "周二":
                System.out.println("222。解决bug");
                break;
            case "周三":
                System.out.println("333干。解决bug");
                break;
            case "周四":
                System.out.println("444。解决bug");
                break;
            case "周五":
                System.out.println("555。解决bug");
                break;
            default:
                System.out.println("日期数据错误");
        }
​
//如果没有default且不属于任何一个case的情况，则什么都不执行。
//        default:
//        System.out.println("日期数据错误");
    }
​
}
​

1.switch分支的格式，执行流程是什么样的？请你描述一下

switch后面写表达式，大括号内跟case，case后跟值，case中有条件内容，break，最后写default:

[重点]2.if、switch的比较，各自适合什么业务场景？

if功能远远强大于switch

• if适合做条件是区间判断的情况；

• switch适合做：条件是比较值的情况、代码优雅，性能较好。

  • if和switch有什么区别？

    其实if分支结构中()的表达式，以boolean类型居多，当然也可以写字面量。不过不能写变量。

    而switch分支结构后的()，中以基本类型（byte、short、int、char）（不支持double、float、long）、枚举、String 及对应包装类。

[重点]三大注意事项

1.表达式类型只能是byte、short、int、charJDK5开始支持枚举，JDK7开始支持String。不支持double、float、long。

总结一下：switch后括号内，只能是基本类型（byte、short、int、char，不支持double、float、long）、枚举、String、包装类（如 Integer、Character），依赖自动拆箱为基本类型。

[重点]为什么不支持double、float？

因为浮点数的精度不准确，底层在计算机中是不能精确表达的。

例如:0.5是2^-1次方表示，0.1+0.2就不能精确表达为0.3。

详情见：switch为什么不支持float和double？

• 为什么支持long？

其实是没必要，int匹配值的数量足够了，不需要long那么多。

2.case给出的值不允许重复，且只能是[字面量]，不能是变量。

• 为什么case后的只能是字面量？

会报错，其实因为是根据匹配值来决定执行的。而变量其实会改变。

3.case穿透现象——千万不要遗忘break

如果没有break，

匹配到周二，没有break，不会跳出switch分支结构，那么会一直匹配到周三、周四...直到遇到break。

• 代码示例:

  public class SwitchDemo05 {
      /*
      *case穿透现象展示，如果没有break，不会跳出switch分支结构
      * */
      public static void main(String[] args) {
          byte a = 10;
          switch (a){
              case 10:
                  System.out.println("我是10");
              case 11:
                  System.out.println("11");
              case 12:
                  System.out.println("12");
                  break;
              case 13:
                  System.out.println("13");
                  break;
          }
      }
  }

[应用]switch穿透性简化代码

• 当存在多个case分支的代码相同时，可以把相同的代码放到一个case块中，其他的case块都通过 穿透到该case块执行代码即可，这样可以简化代码。

  放到一个case块的case块中，其他case块只写分支条件，不写分支内容。

周一：埋头苦干，解决bug
​
周二：请求大牛程序员帮忙
​
周三：请求大牛程序员帮忙
​
周四：请求大牛程序员帮忙
​
周五：自己整理代码
​
周六：打游戏
​
周日：打游戏

二、三、四这几个case其实是一样的。

那么我们可以直接二、三周的分支内容不写，也不写break，只写周四的分支内容

• 代码示例：

  public class SwitchDemo04 {
      public static void main(String[] args) {
  ​
  //利用穿透特性，简化代码
          String week = "周二";
  ​
          switch(week){
              case "周一":
                  System.out.println("我是周一");
                  break;
              case "周二"://没有break且分支内容不用写
              case "周三":
              case "周四":
                  System.out.println("我是周二、三、四的内容，我们是一致的");
                  break;
              case "周五":
                  System.out.println("我是周五");
                  break;
              case "周六":
                  System.out.println("我是周六");
                  break;
              case "周天":
                  System.out.println("我是周天");
                  break;
              default:
                  System.out.println("如果输入的值不存在或者与任何一个case不匹配，输出我default");
          }
      }
  }

回顾

switch有哪些注意事项？

switch(){

}

1.中间()的表达式只能是byte、short、int、char、JDK5开始支持枚举、JDK7开始支持String。

不支持float、double、long。

2.case: 后的值只能是字面量，不能是变量。

3.不要忘记写break，否则会出现case穿透现象。

4.case穿透现象应用的时候，case的分支内容不用写，只用写分支的条件。

穿透性能解决什么问题？

简化代码。当多个case分支内容一致的时候，可以把case内容写到末尾的一个case块中，其他case通过穿透特性，都使用末尾case块中的分支内容。来简化代码。

什么是分支结构？

根据条件，选择相应的分支进行执行。

什么是循环结构？

控制一段代码能执行多次

循环结构

控制一段代码能执行多次

初识for循环

初始化语句、循环条件、迭代语句。

循环体语句。

要熟悉这些术语。

for(初始化语句;循环条件;迭代语句){
    循环体语句;
}

public class ForDemo01 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("我会输出5编");
        }
        for(int i = 1; i <= 3;i++){
            System.out.println("我会输出3遍");
        }
        for(int i = 0;i < 10;i += 2){
            System.out.println("我会按照02468一共5遍");
        }
    }
}
​

for循环

for循环控制的其实是i的数值，可以用于批量产生数据。

public class ForDemo01 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("我会输出5编");
        }
        for(int i = 1; i <= 3;i++){
            System.out.println("我会输出3遍");
        }
        for(int i = 0;i < 10;i += 2){
            System.out.println("我会按照02468一共5遍");
        }
    }
}
​

奇数和

回顾

详细说说如何实现求1-5的数据和的？

首先使用for循环，初始条件写i=1;判断条件写i<=5;迭代条件写i++;

然后获取所有的i，我们使用sum变量进行累加i

sum = sum + i;进行累加求和

最终在for循环体外部进行输出sum的值。得到1-5的数据和。

详细说说如何实现求1-10奇数和的？

方法一：获取1-10的奇数

for的()中的迭代条件中我们写i+=2，让i以每次2的步长进行增加。

那么从1开始，1，3，5...获得到的都是奇数，然后累加求和输出、

方法二：获取1-10的所有数，判断是否为奇数。

for循环中的迭代条件写i++获取到1-10的所有数，

然后使用if(i%2 == 1){sum += i}进行累加，然后输出。

代码：

package com.itheima.branch;
​
public class ForDemo06 {
//    利用for循环批量产生数据
    public static void main(String[] args) {
        for(int i = 0;i <=100; i++){
            System.out.println(i);
        }
​
    System.out.println("---");
//1-5求和,并输出
​
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            //sum = sum + i;
        }
        System.out.println(sum);
​
    System.out.println("---");
//奇数和方法一
    //步骤
    //1.获取1-10的奇数
    //2.求和
    //3.输出
        int sum2 = 0;
        for (int i = 1; i <= 10; i+=2) {
            //1,3,5
            sum2 += i;
        }
        System.out.println("奇数和是：" + sum2);
    System.out.println("---");
//奇数和方法二
/* 步骤
* 1.获取所有的i
* 2.判断是否是奇数
* 3.求和
* 4.输出
* */
        int sum3 = 0;
        for (int i = 1; i <= 10; i++) {
            if(i % 2 == 0){
                sum3 += i;
            }
            System.out.println("所有的奇数和是" + sum3);
        }
    }
}

while循环

初始化语句;
while(循环条件){
    循环体语句;
    迭代语句;
}

//示例
int i = 0;
while(i < 3){
    System.out.println("helloworld");
    i++;//如果去除,则陷入无限循环。
}

与for循环的结构组成一样，功能上没有区别。

[重点案例]如何选择for和while？

如果执行一个循环，知道要执行多少次，我们优先for循环，不知道执行多少次使用while循环。

但for循环也可以实现不知道要执行多少次的条件。while也能实现知道明确次数的问题。

例如：一张纸0.001m，珠峰8848.86m。问需要折叠多少次，至少能达到珠峰的高度？

public class WhileTest01 {
    public static void main(String[] args) {
        //纸张和珠峰的案例
        //理解while循环应用场景
        //1.定义变量
        double peek = 8848.86;
        double paper = 0.001;
​
        //记录折叠次数
        int count = 0;
        while( paper <= peek ) {
            paper *= 2;
            count ++;
        }
        System.out.println("需要折叠的次数" + count);
        System.out.println("最终的纸张的厚度" + paper);
​
        System.out.println("-----");
//使用for循环实现,将while改为for循环。这里for循环并没有明确的循环次数，也可以实现
        int count1 = 0;
        for(double peek1 = 8848.86,paper1 = 0.001;paper1 <= peek1; paper1 *= 2){
            count1 ++;
        };
        System.out.println("for循环实现的需要折叠的次数" + count1);
//        System.out.println("for循环实现最终的纸张的厚度" + paper1);//报错因为paper1在循环条件内,放到外部定义就可以输出了
    }
}

---

do while循环

初始化语句;
do {
    循环体语句;
    迭代语句;
}while(循环条件);

特点：先执行后判断。

public class DowhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        do{
            System.out.println("Hello World");
            i++;
        }while(i<5);
​
        System.out.println("=========");
    //无论怎样，dowhile总要先执行一次do中的循环体语句和迭代语句
        do{
            System.out.println("Hello World111");
            i++;
        }while(false);
    }
}
​

抢票软件：先抢，然后再判断。

三种循环的区别小结

for循环和whle循环（先判断后执行)；do while（先执行后判断)

for循环和while循环的执行流程是一模一样的，功能上无区别，for能做的while也能做，反之亦然。

使用规范：如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。

[重点]其他区别：for循环中，控制循环的变量只在循环中使用。while循环中，控制循环的变量在循环后还可以继续使用。

死循环

public class EndlessLoopDemo {
    public static void main(String[] args) {
        /*死循环写法
        * 以下是非常好的掌握for、while、do while循环的初始化语句、循环语句、迭代语句的好方法。
        * */
​
//        for死循环
/*        for ( ; ; ) {
            System.out.println("helloworld");
        }*/
​
//        while死循环
/*        int i = 1;//初始化语句
        while (true) {
            System.out.println("helloworld");
        }*/
​
//        do while死循环
        int i = 1;//初始化语句
        do{
            System.out.println(i);//循环语句
            i++;//迭代语句
        }while(true);//循环条件
​
    }
}

[重点]基本for循环操作

实现4行5列的*

public class NestLoopDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 4; i++) {//外层循环决定——>行
            System.out.println();//仅换行
            for (int j = 1; j <= 5; j++) {//内层循环——>列
                System.out.print("*");//不换行
            }
        }
    }
}

这里我们知道先打印一个换行，然后执行5个内层循环打印五个*。

后执行剩余3个换行，与第一个换行执行的一样。

九九乘法表

public class NestLoopDemo1 {
    public static void main(String[] args) {
        //九九乘法表
//        九九乘法表是行的序号 等于 该行的列数
//        代码是一层层打印的，打印每层的时候：乘法表的列数取决于，外层循环进行到的行数。
​
        //一、9*9方块
/*        for (int i = 1; i <=9 ; i++) {
            System.out.println();
            for (int j = 1; j <=9 ; j++) {
                System.out.print("1*1=1" + " ");
            }
        }*/
//二、最终
        for (int i = 1; i <=9 ; i++) {
            System.out.println();
            for (int j = 1; j <=i ; j++) {
                System.out.print(j + "*" +  i + "=" +  i*j + " ");
            }
        }
    }
}

肌肉记忆操作

System.out.println("1+1=2");
改为System.out.println("1+"+j+"=2");
​
如何做：
删除需要增加的j，按下左方向键，然后""，再在""中間增加两个++。
    然后左方向键，写上j。

break和continue

break：跳出并结束当前所在循环的执行。

continue:用于跳出当前循环的当次执行，直接进入循环的下一次执行。

一个案例搞明白

public class Demo1 {
    public static void main(String[] args) {
    //学习break和continue
        //案例:女朋友生气了,让你说五遍对不起
        //你说到第三遍的时候,女朋友心软了,然你别说了
        for (int i = 1; i <=5 ; i++) {
            System.out.println("我"+ i+"天洗碗");
            if(i==3){
                break;
            }
        }
​
        System.out.println("===============");
        //案例:你和老婆吵架了,惩罚是洗五天的碗
        //结果第三天是你的生日，让你该天 先 别洗洗碗了
        for (int i = 1; i <= 5; i++) {
//            System.out.println("我"+ i+"天洗碗");//放此处还是会先执行一次，导致第三天还是洗碗
            if (i == 3){//生日
                continue;
            }
            System.out.println("我"+ i+"天洗碗");
        }
​
    }
}
​

break：跳出并结束当前所在循环

continue，跳出当前循环的此次执行，直接进入下一次循环的执行。

注意：

continue：只能在循环中进行使用。

break：只能用于结束所在循环，或者结束所在switch分支的执行。

Random

Random r = new Random();
r.nextInt(10);//生成的是[0,9]的随机数

[重点]减加法

要点：目标区间的范围[A,B]，左区间先减为0（右区间也要减相同的数），然后再将处理后的右区间的数+1作为nextInt()内的值，最后再加上原先的左区间。

就是目标要求产生的随机数。

生成[13,27]的随机数

package com.itheima.conbre;
​
import java.util.Random;
​
public class RandomTest01 {
    public static void main(String[] args) {
        Random r = new Random();
​
        for (int i = 0; i < 10; i++) {
            int num = r.nextInt(10);//生成[0,9]的随机数
            System.out.println(num);
        }
        System.out.println("====");
//减加法：生成任意的随机数
        //左区间先减为0，然后再将右区间的数+1作为nextInt()内的值，最后再加上原先的左区间。
​
//        例：生成[13,44]的随机数
        //[13,44]--->[0,31]--->nextInt(32)+13
​
        Random r1 = new Random();
        for (int i = 0; i < 10; i++) {
            int num1= r1.nextInt(32)+13;
            System.out.println(num1);
        }
​
    }
}
​

再测试一下，

package com.itheima.conbre;
​
import java.util.Random;
​
public class RandomTest03 {
    public static void main(String[] args) {
        //随机数产生练习
        //我要66-95之间的随机数。
        //[66,95]--->[0,29]--->netInt(30)+66——>同减去66,然后()内是减去的右区间结果+1，再加初始的左区间
​
        for (int i = 1; i <=30 ; i++) {
            Random r = new Random();
            int num = r.nextInt(30)+66;
            System.out.println(num);
        }
​
    }
}
​

[重点]案例：猜数字

思路：写单次输入的最简单demo--->确定次数有没有限制？--->for还是while--->改为多次输入。

​
import java.util.Random;
import java.util.Scanner;
​
public class RandeomTest02 {
    public static void main(String[] args) {
​
//        猜一个2-9之间的数字，猜对了输出结果，猜错了输出结果，
        //分析随机数[2,9]--->[0,7]--->nextInt(8)+2//减去左区间的数字，然后再
        Random r = new Random();
        int rnum = r.nextInt(8)+2;
​
        //ctrl + alt + t
        while (true) {
        //循环体
            //接收数字，每次都要执行
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字");
            int num= sc.nextInt();
​
            //每次都要执行
            if(num == rnum){
                System.out.println("恭喜你猜对了");//那么是猜对了,我就会跳出循环,用break!!!跳出循环体
                break;
            } else if (num > rnum) {
                System.out.println("你猜的大了");
            }else if(num <= rnum){
                System.out.println("你猜的小了");
            }
        }
        System.out.println("Bingo,恭喜你跳出循环体,猜对了!");
​
​
    }
}
​

每次的输入也是循环体内，要注意。