Day03

最新推荐文章于 2024-09-16 21:37:07 发布

柑橘木头

最新推荐文章于 2024-09-16 21:37:07 发布

阅读量336

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_68177111/article/details/127826459

版权

Day03

Java程序流程控制

作用：控制程序的执行顺序
常见的三种执行顺序
- 顺序结构：自上而下的执行代码
- 分支结构：根据条件，选择对应的代码
- 循环结构：控制某段代码的重复执行

1、分支结构

1.if

根据条件表达式结果的真假决定执行某段代码
三种形式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PCAwalbc-1668262734103)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112112914145.png)]
- if(条件表达式){语句体}
  - 执行流程：判断条件表达式的结果，true则执行语句体然后跳出分支，否则直接跳出if分支
  - 大括号只有一行代码，大括号可以省略
  - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xKvGwNUh-1668262734104)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112153408024.png)]
- if(条件表达式){语句体2} else{语句体2}
  - 执行流程：判断条件表达式的结果，true则执行语句体1然后跳出分支，否则执行else的语句体2然后跳出分支
  - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LkFXwe1J-1668262734105)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112153504384.png)]
- if(条件表达式1){语句体2} else if(条件表达式2){语句体2} else if(条件表达式3){语句体3} …else{语句体n}
  - 执行流程：判断条件表达式1的结果，true则执行语句体1然后跳出分支；false则判断条件表达式2的结果，true则执行语句体2然后跳出分支，…没有任何条件为true，执行else分支
  - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pldozJGf-1668262734105)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112153530962.png)]
if常见的问题：
- if(条件){}，()后不能跟“;”否则{}中的代码将不受if的控制了。
- 如果if语句的{}中只有一行代码的情况，{}可以省略不写（但是不推荐省略）。

package com.itheima.branch;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        //if分支
        //1.if(表达式){语句体}
        //需求：测体温，超过或等于37.3报警
        double temp = 36.3;
        if (temp>=37.3){
            System.out.println("报警");
        }
        System.out.println("测温结束");

        System.out.println("========================");
        //2.if(表达式1){语句体1}else{语句体2}
        //需求，发红包
        double money = 100;
        if (money>=78.6){
            System.out.println("成功");
        }
        System.out.println("余额不足");
        System.out.println("========================");

        //2.if(表达式1){语句体1}else if(表达式2){语句体2}else if(表达式3){语句体3}...else {语句体n}
        //需求：绩效考核 ，成绩为整数
        int score = 81;
        if (score>=90&&score<=100){//用&&比用&好，因为左边false，右边直接不执行，节省资源
            System.out.println("A");
        }else if (score>=89&&score<=80){
            System.out.println("B");
        }else if (score>=60&&score<=79){
            System.out.println("C");
        }else if (score>=0&&score<=59){
            System.out.println("D");
        }else {
            System.out.println("输入错误");
        }
        System.out.println("========================");

        //需求，键盘录入成绩
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入成绩");
        int i = scanner.nextInt();
        if (i>=95&&i<=100){
            System.out.println("自行车");
        }else if (i>=90&&i<=94){
            System.out.println("游乐园");
        }else if (i>=80&&i<=89){
            System.out.println("变形金刚");
        }else if (i>=0&&i<=79){
            System.out.println("挨打");
        }else { //键盘录入，scanner接收的是整数，所以键盘输入必须是整数，否则会报错
            System.out.println("错误");
        }

    }
}

练习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fYDykThI-1668262734106)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112154920157.png)]

package com.itheima.branch;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        //需求，键盘录入成绩
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入成绩");
        int i = scanner.nextInt();
        if (i>=95&&i<=100){
            System.out.println("自行车");
        }else if (i>=90&&i<=94){
            System.out.println("游乐园");
        }else if (i>=80&&i<=89){
            System.out.println("变形金刚");
        }else if (i>=0&&i<=79){
            System.out.println("挨打");
        }else { //键盘录入，scanner接收的是整数，所以键盘输入必须是整数，否则会报错
            System.out.println("错误");
        }

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2wm5dBPH-1668262734106)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112160849323.png)]

package com.itheima.branch;

import java.util.Scanner;

public class IfTest {
    public static void main(String[] args) {
        //需求: 键盘录入用户密码, 如果密码为 111111, 程序输出密码正确，否则输出密码有误
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入密码");
        int i = scanner.nextInt();
        if (i == 111111){
            System.out.println(true);
        }else {
            System.out.println(false);
        }
    }
}

2.switch

switch通过比较值来决定进行哪个分支

switch(表达式){
  case 1:
  语句体1;
  break;
  case 2:
  语句体2;
  break;
  ...
  case n-1:
  语句体;
  break;
  default:
  语句体 n;
}

switch执行流程
- 先执行表达式的值，然后拿这个值去与case的值匹配
- 与哪个case的匹配后，就执行对应的语句体，遇到break就跳出switch分支
- 如果都不匹配，则执行default后的语句体

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYSCSU3a-1668262734107)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112163234488.png)]

package com.itheima.branch;

public class SwitchDemo {
    public static void main(String[] args) {
        //switch分支
        // 目标：掌握switch分支的写法，并理解其执行流程
        // 需求：模拟一个电子备忘录系统
        // 周一：埋头苦干，解决bug
        // 周二：	请求大牛程序员帮忙
        // 周三：今晚啤酒、龙虾、小烧烤
        // 周四：主动帮助新来的女程序解决bug
        // 周五：今晚吃鸡
        // 周六：与王婆介绍的小芳相亲
        // 周日：郁郁寡欢、准备上班。


        String weekday = "周五";
        switch (weekday) {
            case "周一":
                System.out.println("埋头苦干，解决bug ");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤 ");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug ");
                break;
            case "周五":
                System.out.println("今晚吃鸡 ");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲 ");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班 ");
                break;
            default:
                System.out.println("输入有误");
        }
    }
}

if与switch的比较（各自适合什么业务场景）
- if在功能上远远大于switch
- 当条件是区间的时候，使用if分支结构
- 当条件是与一个一个值比较的时候，使用switch，更合适，因为switch格式良好，性能较好，代码优雅
  - switch性能好是因为得到表达式的值后，直接去寻找相同的值，而if却是要从上到下一个一个去匹配

使用switch需要注意的事项

表达式数据类型只能是byte，short，int，char，JDK5支持枚举，JDK7支持String，不支持long，float，double
case后面的值不可以重复，只能是字面量，不能是变量

正常使用switch的时候，不要忘记写break ，否则会出现穿透现象

swit的穿透性在某些情况下可以简化代码

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I89dQzTz-1668262734108)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112185825945.png)]

package com.itheima.branch;

import java.util.Scanner;

public class SwitchDemo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入月份");
        int mouth = scanner.nextInt();
        switch (mouth){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println("本月为31天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println("本月为30天");
                break;
            case 2:
                System.out.println("闰年为29天，非闰年为28天");
                break;
            default:
                System.out.println("输入有误");
        }

    }
}

package com.itheima.branch;

public class SwitchDemo02 {
    public static void main(String[] args) {
//        表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
        char a  =20;
        double i = 0.1;
        double j = 0.2;
        double m = i + j;//结果为0.30000000000000004 ，不是0.3，故不能在switch分支进行匹配
        //long范围太大，没必要，switch匹配太麻烦
        //小数运算不精确

        float b = 0.1f;
        float c = 0.2f;
        float n = b + c;
        System.out.println(n);
        System.out.println(m);
        switch (a){

        }

        int e = 20;

        //        case给出的值不允许重复，且只能是字面量，不能是变量。
        switch (a){
//            case e:
//            case 20:
//                System.out.println(true);
//                break;
//            case 20:

        }

        //        正常使用switch的时候，不要忘记写break，否则会出现穿透现象。
        String weekday = "周五";
        switch (weekday) {
            case "周一":
                System.out.println("埋头苦干，解决bug ");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤 ");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug ");
                break;
            case "周五":
            case "周六":
            case "周日":
                System.out.println("今晚吃鸡 ");
                break;
            default:
                System.out.println("输入有误");
                //今晚吃鸡
                //与王婆介绍的小芳相亲
                //郁郁寡欢、准备上班
                //输入有误
        }
    }
}

2、循环结构

1.for循环

控制一段代码执行很多次
格式：
- for(初始化语句;循环条件;迭代语句){
  
  循环语句体（重复执行的代码）
  
  }
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yy91LC6J-1668262734109)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112190221883.png)]
for循环执行流程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YYDSMTvd-1668262734111)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112190323735.png)]
- 1.循环开始，执行int i= 0
  
  2.此时i=0,接着计算机执行循环条件语句：0<3，返回true，计算机跳到循环语句体执行，返回Hello World,然后执行迭代语句 i++
  
  3.此时i=1,接着计算机执行循环条件语句：1<3，返回true，计算机跳到循环语句体执行，返回Hello World,然后执行迭代语句 i++
  
  4.此时i=2,接着计算机执行循环条件语句：2<3，返回true，计算机跳到循环语句体执行，返回Hello World,然后执行迭代语句 i++
  
  5.此时i=3,接着计算机执行循环条件语句：3<3，返回false，循环立即结束
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ov8O3Yxx-1668262734112)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112190935007.png)]
for循环常见场景：减少代码的重复编写，灵活的控制程序的执行。

package com.itheima.loop;

public class ForDemo {
    public static void main(String[] args) {
        //for循环
        /*
        for(初始化语句;条件语句;迭代语句){
          循环体;
           }
           */
        //需求8888打印 12次
        for (int i = 1; i < 13; i++) {// < 判断次数是 ：小于号后面的-初始值
            System.out.println("8888");
        }
        System.out.println("============");

        for (int i = 2; i <= 13; i++) {// <=判断次数是：<=好后面的-初始值+1
            System.out.println("8888");
        }
        System.out.println("===================");
        
        int j = 0;
        //需求：1-100的和?
        for (int i = 0; i < 101; i++) {
            j += i;
        }
        System.out.println(j);
    }
}

for循环案例1：求和

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0RApNuIa-1668262734113)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112191604773.png)]

package com.itheima.loop;

public class ForTest {
    public static void main(String[] args) {
        //for循环的应用
        //1-5之间整数的和
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        System.out.println("1-5之间整数的和"+sum);
    }
}

for循环案例2：求奇数和

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ykiSpN7-1668262734113)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112191623914.png)]

package com.itheima.loop;

public class ForTest2 {
    public static void main(String[] args) {
        //for循环的应用
        // 需求：1-10之间奇数数的和
        //方法一
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            if (i%2 == 1){
                sum+=i;
            }
        }
        System.out.println("1-10之间奇数的和:"+sum);

        System.out.println("==============");

        //方法二
        int sum2 = 0;
        for (int i = 1; i <11 ; i+=2) {
            sum2+=i;
        }
        System.out.println("1-10之间奇数的和"+sum2);


        //        1-10之间偶数的和
        int sum3 = 0;
        for (int i = 0; i < 11; i+=2) {
            sum3+=i;
        }
        System.out.println("1-10之间偶数的和"+sum3);
    }
}

for循环案例：打印水仙花数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-agZ9GpVs-1668262734114)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112191734220.png)]

package com.itheima.loop;

public class ForTest3 {
    public static void main(String[] args) {
        //for循环的应用
        //需求：在控制台输出所有的“水仙花数”，水仙花数必须满足如下2个要求：水仙花数是一个三位数；水仙花数的个位、十位、百位的数字立方和等于原数

        int count = 0;
        for (int i = 100; i < 1000; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;
            if (ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
                System.out.print(i+"\t");
                count++;
            }
        }
        System.out.println();//代表换行
        System.out.println("水仙花个数："+count);
    }
}

2.while循环

格式：
- 初始化语句
  
  while（循环条件）{
  
  循环体条件（被重复执行的代码）
  
  迭代语句
  
  }
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-12FNfgN1-1668262734115)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112192228291.png)]
执行流程：
- 循环一开始，执行int i = 0 一次。
  此时 i=0 ，接着计算机执行循环条件语句：0 < 3 返回true , 计算机就进到循环体中执行，输出：helloWorld ，然后执行迭代语句i++。
- 此时 i=1 ，接着计算机执行循环条件语句：1 < 3 返回true , 计算机就进到循环体中执行，输出：helloWorld ，然后执行迭代语句i++。
- 此时 i=2 ，接着计算机执行循环条件语句：2 < 3 返回true , 计算机就进到循环体中执行，输出：helloWorld ，然后执行迭代语句i++。
- 此时 i=3 ，然后判断循环条件：3 < 3 返回false, 循环立即结束！！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qGVsAGit-1668262734115)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112192403786.png)]

package com.itheima.loop;

public class WhileDemo {
    public static void main(String[] args) {
        //while循环
        int i =0;
        while (i<3){
            System.out.println(8888);
            i++;
        }
    }
}

while与for的区别
- 功能上完全一样，for能解决的while也能解决，反之亦然；
- 使用规范：在不知道循环几次的时候用while，知道几次循环的时候用for
案例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3A22rrt5-1668262734116)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112193049389.png)]

package com.itheima.loop;

public class WhileTest {
    public static void main(String[] args) {
        //需求：世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米,它的厚度是0.1毫米。请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？

         double peakHeight = 8848860;  // 山峰高度
//                          13421772.8  =1.34217728E7      E7=10的7次方
         double paperThickness = 0.1;  // 纸张厚度
        int count = 0;
        while (paperThickness<peakHeight){
            paperThickness*=2;
            count++;
        }
        System.out.println("纸张折叠次数:"+count+"\t"+"纸张高度:"+paperThickness);
    }
}

3.do-while循环

结构
- 初始化语句
  
  do{
  
  循环体语句；
  
  迭代语句；
  
  }while(循环条件)；
执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M72Nsz5S-1668262734116)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112193425398.png)]

do-while循环的特点：先执行后判断，一定会执行一次循环体

package com.itheima.loop;

public class DoWhileDemo {
    public static void main(String[] args) {
        //do-while循环
        int i= 0;
        do {
            System.out.println(8888);
            i++;
        }while (i<3);
        System.out.println(i);

    }
}

三种循环体的区别
- for循环和while循环都是先判断再执行，do-while是先执行后判断
- for循环与while循环的执行流程一样，功能没区别
- 使用规范：在不知道循环几次的时候用while，知道几次循环的时候用for
- 其他区别，for循环中控制循环的变量只能在循环中使用。while循环中的控制循环变量在循环后仍可以使用（for循环变量定义在for循环语句体里，while循环变量定义在while语句体外）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pc1LAPcC-1668262734117)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112214956305.png)]

4.死循环

可以一直执行下去的循环，没有人为干预不能停下来
3种写法
- for( ; ; ){
  
  循环语句体；
  
  }
- while(true){
  
  循环语句体；
  
  }
- do{
  
  循环语句体；
  
  }while(true）
while死循环是最经典常用的死循环：比如说服务器程序

package com.itheima.loop;

public class DeadLoop {
    public static void main(String[] args) {
        //for死循环
//            for (;  ; ) {
//                System.out.println(6666);
//            }

        //因为for死循环一直执行，所以会导致while死循环排不上，会报错，要取消for循环才可
        //while死循环
        while (true) {
            System.out.println(8888);

        }

//            //do-while死循环
//            do {
//                System.out.println(9999);
//            }while (true);
        }
    }
}

练习

package com.itheima.loop;

import java.util.Scanner;

public class DeadLoopTest {
    public static void main(String[] args) {
      int psd = 520;
        Scanner scanner = new Scanner(System.in);//在外边因为创建对象占用内存空间，在死循环里会不断创建对象，浪费内存
        while (true){
//            Scanner scanner = new Scanner(System.in);
            System.out.println("输入密码");
            int password = scanner.nextInt();

            if (password == psd ){
                System.out.println("欢迎进入");
                break;
            }else {//可读性好
                System.out.println("密码错误");
            }
//            if (password == psd ){
//                System.out.println("欢迎进入");
//                break;
//            }
//            System.out.println("密码错误");
        }

    }
}

5.循环嵌套

循环里面又包含循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V6G7aNDX-1668262734117)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112215900699.png)]
循环嵌套的特点：
- 外部每循环一次，内部循环全部执行完一轮
案例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mITV3T8Q-1668262734118)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112220134616.png)]

package com.itheima.loop;

public class NestedLoop {
    public static void main(String[] args) {
        //循环嵌套
        //打出一个4行5列的*矩形
        for (int i = 0; i <4 ; i++) {
            for (int j = 0; j <5 ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        //九九乘法表
        for (int i = 1; i <10 ; i++) {
            for (int j = 1; j < = i ; j++) {
                int num= i*j;
//                System.out.print(num+"="+i+"*"+j+"\t");
                System.out.print(i+"*"+j+"="+num+"\t");
            }
            System.out.println();
        }
    }
}

3、跳转关键字：break，continue

break：表示跳出并且结束循环的执行
continue：表示跳出本次循环，直接进入到下一个循环
注意：
- break：只能用于结束所在循环，或者switch分支使用
- continue：只能在循环中进行

package com.itheima.loop;

public class BreakAndContinueDemo {
    public static void main(String[] args) {
        //break
        //在第6次结束循环
        for (int i = 0; i < 20; i++) {
            System.out.println(i);
            if (i ==5 ){
                break;
            }
        }

        System.out.println();

        //continue
        //第3次循环不执行
        for (int i = 0; i < 6; i++) {
            if (i ==2 ){
                continue;
            }
            System.out.println(i);
        }


    }
}

案例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wigH5UJ1-1668262734118)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112220629335.png)]

package com.itheima.loop;

import java.util.Scanner;

public class DeadLoopTest {
    public static void main(String[] args) {
      int psd = 520;
        Scanner scanner = new Scanner(System.in);//在外边因为创建对象占用内存空间，在死循环里会不断创建对象，浪费内存
        while (true){
//            Scanner scanner = new Scanner(System.in);
            System.out.println("输入密码");
            int password = scanner.nextInt();

            if (password == psd ){
                System.out.println("欢迎进入");
                break;
            }else {//可读性好
                System.out.println("密码错误");
            }
//            if (password == psd ){
//                System.out.println("欢迎进入");
//                break;
//            }
//            System.out.println("密码错误");
        }

    }
}

4、案例技术：生成随机数

1.Random随机数的生成

Random作用:生成随机数，只能是[0,9]

import java.util.Random;

public class Demo {
    public static void main(String[] args) {
        //Random随机数
        Random r = new Random();
        int number = r.nextInt(10);
        System.out.println("随机生成了："+number);
    }  
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UdpXDZ7c-1668262734119)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112221348160.png)]

2.生成任意区间的随机数

区间：[m,n]，那么 int number = r.nextInt==(n-m+1)+m==;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zrE1FYDa-1668262734120)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112221725659.png)]

案例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ixe7FxdE-1668262734120)(C:\Users\王超越\AppData\Roaming\Typora\typora-user-images\image-20221112221812018.png)]

package com.itheima.random;

import java.util.Random;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //Random随机数
        //需求：猜1-100的随机数
        Random r = new Random();
        int i = r.nextInt(100) + 1;
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("输入您要猜的1-100数");
            int j = scanner.nextInt();
            if (j > i){
                System.out.println("您输入的数大了");
            }else if (j<i){
                System.out.println("您输入的数小了");
            }else {
                System.out.println("您输入的数正确，撒花");
                break;
            }
        }
    }
}
]

#### 2.生成任意区间的随机数

- 区间：[m,n]，那么 int number = r.nextInt==(n-m+1)+m==;

[外链图片转存中...(img-zrE1FYDa-1668262734120)]

- 案例：

  [外链图片转存中...(img-Ixe7FxdE-1668262734120)]

```java
package com.itheima.random;

import java.util.Random;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //Random随机数
        //需求：猜1-100的随机数
        Random r = new Random();
        int i = r.nextInt(100) + 1;
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("输入您要猜的1-100数");
            int j = scanner.nextInt();
            if (j > i){
                System.out.println("您输入的数大了");
            }else if (j<i){
                System.out.println("您输入的数小了");
            }else {
                System.out.println("您输入的数正确，撒花");
                break;
            }
        }
    }
}