003-Java程序流程控制

3. Java程序流程控制(重点)

• 程序的三种控制结构
• 

3.1 分支结构 if, switch

3.1.1 if

1. if 分支

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

2. if分支应用场景

   • 

3. if 第一种形式

   • 
   • 执行流程：
   • 首先判断条件表达式的结果，如果为true执行语句体，为false就不执行语句体。

4. if 第二种形式

   • 
   • 执行流程：
   • 首先判断条件表达式的结果，如果为true执行语句体1，为 false 就执行语句体2。

5. if 第三种形式

   • 
   • 执行流程：
   • 先判断条件1的值，如果为true则执行语句体1，分支结束；如果为false则判断条件2的值
   • 如果值为true就执行语句体2，分支结束；如果为false则判断条件3的值
   • ...
   • 如果没有任何条件为true，就执行else分支的语句体n+1。

6. 总结

   1. if分支的作用是什么？
      
      可以根据条件，选择执行某段程序
   2. if分支的写法有几种？
      • 

7. 多学一招: if使用的几个常见问题

   • 如果if语句的{}中只有一行代码的情况，{}可以省略不写（但是不推荐省略）.
   • if(条件){}，()后不能跟“;”否则{}中的代码将不受if的控制了.

8. 练习: 用户登录

   • 

package com.itheima.a_if;
import java.util.Scanner;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
if 案例: 用户登录
    需求: 键盘录入用户名和密码
        如果用户名不是1, 程序输出:用户名错误
        如果密码不是2, 程序输出:密码错误
        如果用户名和密码没问题, 程序输出:登录成功
    提示:
        使用Scanner接收用户输入的信息，并使用变量接收
        使用if...else if...else 组织程序逻辑
*/
public class Demo03 {
    public static void main(String[] args) {
//        1. 创建一个自己的扫描器
        Scanner sc= new Scanner(System.in);
//        2.提示用户输入用户名
        System.out.print("请输入用户名: ");
        int name = sc.nextInt();
//        提示用户输入密码
        System.out.print("请输入密码: ");
        int passWord= sc.nextInt();
        if(name!=1){
            System.out.println("用户名错误!!!");
        }else if(passWord!=2){
            System.out.println("密码错误!!!");
        }else{
            System.out.println("登录成功!!!");
        }

    }
}

3.1.2 switch

1. switch分支
   • 是通过比较值来决定执行哪条分支。
   • 
2. switch分支的执行流程
   • 先执行表达式的值，再拿着这个值去与case后的值进行匹配。
   • 与哪个case后的值匹配为true就执行哪个case块的代码，遇到break就跳出switch分支。
   • 如果全部case后的值与之匹配都是false，则执行default块的代码。
3. if跟switch的比较
   • if适合做区间匹配，功能更加强大.
   • switch适合做值匹配，性能更好.
4. 总结:
   • switch分支的格式、执行流程是怎么样的？
     • 
   • if、switch的区别有哪些？
     • if适合做区间匹配，功能更加强大.
     • switch适合做值匹配，性能更好.

3.1.3 switch使用时注意事项

1. 使用switch分支的几点注意事项
   • 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long。
   • case给出的值不允许重复，且只能是字面量，不能是变量。
   • 正常使用switch的时候，不要忘记写break，否则会出现穿透现象。
   • 当case中没有写break时,就会开启穿透,后续的case不再匹配,直接执行, 直到遇到下一个break或者整个switch执行完毕后才结束, 穿透现象是可以加以利用, 优化代码的.

3.1.4 总结

1. 使用switch时有哪些注意事项?

• 表达式类型可以是byte、short、int、char、枚举、String，不能是double、float、long
• case给出的值不允许重复，且只能是字面量，不能是变量.
• 正常使用switch的时候，不要忘记写break，否则会出现穿透现象。

1. switch穿透性能解决什么问题？

• 存在多个case分支的代码是一样时，可以把代码写到一个case块，其他case块通过穿透性能，穿透到该case块即可，这样可以简化代码。

1. 案例:

package com.itheima.b_switch;

import java.util.Scanner;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
分支结构 switch
  1. 使用待匹配的值去匹配对应的case值, 执行对应的语句体, 遇到break就结束switch语句
  2. 所有的case都匹配不到,则执行default中的语句体

  switch(待匹配的值){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
        ....
    case 值n:
        语句体n;
        break;
    default:
        语句体;
        break;
  }
*/

/*
switch注意事项:
    1. 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
    2. case给出的值不允许重复，且只能是字面量，不能是变量。
    3. 正常使用switch的时候，不要忘记写break，否则会出现穿透现象。

switch的case穿透
    当case中没有写break时,就会开启穿透,后续的case不再匹配,直接执行,直到遇到下一个break或者整个switch执行完毕后才结束
    穿透现象是可以加以利用, 优化代码的
 */

public class Demo01 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //需求: 根据今天星期几, 判断是工作还是休息
        System.out.print("请输入今天星期几: ");
        int weekDay= sc.nextInt();
        switch(weekDay){
            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("输入错误!!!");
        }

        //需求: 根据定义的月份month,输出对应的季节
        // 3、4、5：春季
        //6、7、8：夏季
        //9、10、11：秋季
        //其它 : 输入月份有误
//        如果发现上下有多个case下的代码完全能相同, 可以利用穿透现象进行简写,只写最后一个case里的代码

        System.out.print("请输入月份: ");
        int month = sc.nextInt();
        switch(month){
            case 12:
            case 1:
            case 2:
                System.out.println("现在是冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("现在是春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("现在是夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("现在是秋季");
                break;
            default:
                System.out.println("输入月份有误!!!");
        }

    }
}

3.2 循环结构 for, while, do-while

3.2.1 for循环

1. for循环

• 控制一段代码反复执行很多次。

1. 应用场景

• 

1. for循环格式

for(初始化语句 ; 条件判断语句;  条件变更语句 ) {
    	循环体语句 ; //要重复执行的代码
}

// 输出3次hello world
for (
    int i = 1;
    i <= 3;
    i++
) {
    System.out.println(“hello world");
}

• 

1. for循环总结:

   • for循环格式和执行流程是什么样的？

    for(初始化语句 ; 条件判断语句;  条件变更语句 ) {
        循环体语句 ; //要重复执行的代码
    }
   
   

   // 输出3次hello world
   for (int i = 1; i <= 3; i++) {
    System.out.println(“hello world");
    }
   
   

   • for循环的作用是什么？
     • 减少代码的重复编写，灵活的控制程序的执行。

3.2.2 for循环案例

1. 案例一: 求和

• 需求：求1-10之间的奇数和，并把求和结果在控制台输出。

• 分析：

  • 使用for循环依次产生：1、2、3、4、5。

  for (int i = 1; i <= 5; i++) {
  
  }
  

  • 在循环外定义一个int类型的变量sum用于求和，循环每产生一个数，就加到sum中去

  int sum = 0；
  for (int i = 1; i <= 5; i++) {
      sum += i;
      }
  
  

  • 循环结束后，输出求和变量即是结果。

package com.itheima.c_for;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
for案例:
    需求：求1-5之间的数据和，并把求和结果在控制台输出。
 */
public class Demo02 {
    public static void main(String[] args) {
        //思路:
        //1.首先使用for遍历出1~5的数, 可以使用计数器i.
        //2. 然后在for循环中依次进行累加  如: sum +=i.
        int sum=0;
        for(int i=1;i<6;i++){
            sum +=i;
        }
        System.out.println("1~5之间的数据和为: "+ sum);
    }

}

1. 案例二: 求奇数和

• 需求：求1-10之间的奇数和，并把求和结果在控制台输出。

• 方式一：

  • 定义for循环，使其能够依次产生：1、2、3、4、5… 10。
  • 在循环外定义一个int类型的变量sum用于求和
  • 循环每产生一个数据，都通过if判断其是否是奇数，是奇数，则进到if中将其加到sum中去。

  for (int i = 1; i <= 10 ; i++) {
    if(i % 2 == 1){
        // i = 1 3 5 7 9
        }
    }
  
  //或者这样
  for (int i = 1; i < 11; i++) {
        if (i%2!=0) {
        }
  }
  

• 方法二:

  • 定义for循环，使其能够依次产生：1、3、5 、7 、9

  for (int i = 1; i <= 10; i+=2) {
  
  }
  

  • 在循环外定义一个整数变量sum，循环每产生一个数据就加到sum中去。
  • 循环结束后，输出sum变量即可。

• 完整代码

package com.itheima.c_for;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
    需求：求1-10之间的奇数和，并把求和结果在控制台输出。
*/
public class Demo03 {
    public static void main(String[] args) {
        //思路:
        //1. 先用for循环遍历出1~10所有数
        //2. 使用if语句判断, 剔除所有偶数
        //3. 最后对遍历出的所有奇数进行累加.
        int sum=0;
        for (int i = 1; i < 11; i++) {
            if (i%2!=0) {
//                System.out.println(i);    //查看一下是否全为奇数
                sum +=i;
            }
        }
        System.out.println("1~10中所有的奇数和为: "+  sum);
    }

}

1. 案例三: 求水仙花数

• 需求：在控制台输出所有的“水仙花数”，水仙花数必须满足如下2个要求：

  • 水仙花数是一个三位数
  • 水仙花数的个位、十位、百位的数字立方和等于原数

• 分析：

  • 定义一个for循环从“100一直到999”。
  • 每次访问到数据后，提取该数据的：个位、十位、百位数字。
  • 使用if判断：个位、十位、百位的数字立方和是否等于原数，等于则输出该数据。

  公式总结：
  个位 ：数值 % 10
  十位 ：数值 / 10 % 10
  百位 ：数值 / 10 / 10 % 10
  千位 ：数值 / 10 / 10 / 10 % 10;
  ...
  
  

  • 完整代码:

  package com.itheima.c_for;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
for案例: 求水仙花数
    1. 水仙花数是一个三位数
    2. 水仙花数的个位、十位、百位的数字立方和等于原数

扩展: 如果还要知道水仙花数的个数怎么办？
*/
public class Demo04 {
    public static void main(String[] args) {
        //思路:
        //先定义三个变量来保存三位数的个位、十位、百位的数.
        //再定义一个temp来临时保存个位、十位、百位的数字立方和.
        //判断temp 是否与i相等, 如果相等就位水仙花数.
        //输出每一个水仙花数.
        int a,b,c,temp;
        System.out.print("所有的水仙花数为:");
        for (int i = 100; i <1000; i++) {
            a=i%10;
            b=i/10%10;
            c=i/100%10;
            temp=a*a*a+b*b*b+c*c*c;
            if(i==temp){
                System.out.print(temp+", ");
            }
        }
    }
}

3.2.3 while循环

1. while 循环

初始化语句;
while (条件判断语句) {
    循环体语句;//被重复执行的代码
    条件变更语句;
}

int i = 1;
while (i <= 3) {
    System.out.println("Hello World");
    i++;
}

1. 执行流程:

   • 循环一开始，执行int i = 1 一次。
   • 此时  i=2 ，接着计算机执行循环条件语句：1 <= 3 返回true , 计算机就进到循环体中执行，输出 ：helloWorld ，然后执行迭代语句i++。
   • 此时  i=2 ，接着计算机执行循环条件语句：2 <= 3 返回true , 计算机就进到循环体中执行，输出 ：helloWorld ，然后执行迭代语句i++。
   • 此时  i=3 ，接着计算机执行循环条件语句：3 <= 3 返回true , 计算机就进到循环体中执行，输出 ：helloWorld ，然后执行迭代语句i++。
   • 此时 i=4 ，然后判断循环条件：4 <= 3 返回false, 循环立即结束！！

2. while总结

初始化语句;
while (条件判断语句) {
    循环体语句;//被重复执行的代码
    条件变更语句;
}

int i = 1;
while (i <= 3) {
    System.out.println("Hello World");
    i++;
}

• 入门案例:

package com.itheima.d_while;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
循环结构: while
    格式:
        初始化语句;
        while (条件判断语句) {
            循环体语句;//被重复执行的代码
            条件变更语句;
        }
    执行过程:
        1. 执行一次初始化语句
        2. 执行条件判断语句
            如果不成立, 循环结束
            如果成立, 执行一次循环体
        3. 执行条件变更语句
        4. 重复2、3步骤

*/
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 使用while循环打印5次HelloWorld
        int i=0;
        while(i<5){
            System.out.println("HelloWorld");
            i++;
        }

        //需求2: 说出上面程序的执行顺序
        //定义一个循环变量i=0.
        //进入判断语句, 0<5为true, 进入循环体打印HelloWorld, 再进行i自加
        //进入判断语句, 1<5为true, 进入循环体打印HelloWorld, 再进行i自加
        //进入判断语句, 2<5为true, 进入循环体打印HelloWorld, 再进行i自加
        //进入判断语句, 3<5为true, 进入循环体打印HelloWorld, 再进行i自加
        //进入判断语句, 4<5为true, 进入循环体打印HelloWorld, 再进行i自加
        //进入判断语句, 5<5为false, 跳出for循环

    }
}

3.2.4 while循环案例

• 案例: 纸张折叠成珠穆朗玛峰的高度
• 需求：世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，假如我有一张足够大的纸，它的厚度是0.1毫米。请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？
• 分析
  • 定义变量存储珠穆朗玛峰的高度、纸张的高度。

double peakHeight = 8848860;  // 山峰高度
double paperThickness = 0.1;  // 纸张厚度

• 使用while循环来控制纸张折叠，循环条件是（纸张厚度<山峰高度），循环每执行一次，就表示纸张折叠一次，并把纸张厚度变为原来两倍。

• 循环外定义计数变量count，循环每折叠一次纸张，让count变量+1；

• 完整代码

package com.itheima.d_while;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
案例需求: 珠峰折纸
    已知珠峰的高度是8848860毫米,纸张的厚度是0.1毫米
    问纸张对折几次, 厚度能够达到/超过珠峰高度
*/
public class Demo02 {
    public static void main(String[] args) {
        double peakHeight=8848860;
        double paperThicness = 0.1;
        int count=0;

        //使用while循环编写
//        while(paperThicness<=peakHeight){
//            paperThicness *=2;
//            count++;
//        }

        //使用for循环编写
        //这里不可以直接使用i当作计数器, i的作用域只在for循环中, 出了作用域使用会报错, 就一定得用count来计数.
        for(int i=0;i>=0;i++){
            if(paperThicness<=peakHeight){
                paperThicness *=2;
                count++;
            }else{
                break;
            }
        }

        System.out.println("张对折"+count+"次, 厚度能够达到/超过珠峰高度");
        System.out.println("最终纸张高度是: " + paperThicness);
    }
    //答案:
    //张对折27次, 厚度能够达到/超过珠峰高度
    //最终纸张高度是: 1.34217728E7

}
//思考一下, while和for都可以实现循环,那么使用的时候怎么选择呢?

3.2.5 do-while循环

1. do-while循环

   • 

   初始化语句;
   do {
       循环体语句;
       条件变更语句;
   } while (条件判断语句);
   
   

   int i = 0;
   do {
    System.out.println(“Hello World！");
    i++;
    } while( i < 3);
   

2. do-while循环应用场景示例

• 

1. 入门案例:

package com.itheima.e_do_while;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:

/*
循环结构: do-while循环
    格式:
        初始化语句;
        do {
            循环体语句;
            条件变更语句;
        } while (条件判断语句);
    执行过程:
        1. 执行一次初始化语句
        2. 执行一次循环体语句
        3. 执行一次条件变更语句
        4. 执行条件判断语句
            如果不成立, 循环结束
            如果成立, 重复执行2、3步骤
    特点:
        先执行1次循环体,再进行判断
        也就是说: 无论循环条件是否成立,都会至少执行1次循环体
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 使用do-while循环打印5次HelloWorld
        int i=0;
        do{
            System.out.println("HelloWorld");
            i++;
        }while(i<5);

        //需求2: 说出上面程序的执行顺序
//        1. 执行一次初始化语句
//        2. 执行一次循环体语句
//        3. 执行一次条件变更语句
//        4. 执行条件判断语句
//                如果不成立, 循环结束
//        如果成立, 重复执行2、3步骤

    }
}

3.2.6 三种循环的对比

1. 三种循环的区别小结

• for循环 和 while循环（先判断后执行）; do...while （先执行后判断）
• for循环和while循环的执行流程是一模一样的，功能上无区别，for能做的while也能做，反之亦然。
• 使用规范：如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。
• 其他区别：for循环中，控制循环的变量只在循环中使用。while循环中，控制循环的变量在循环后还可以继续使用。

for (int i = 0; i < 3; i++ ) {
    System.out.println(“Hello World");
    }
System.out.println(i);

int i = 0;
while (i < 3) {
    System.out.println("Hello World");
    i++;
    }
System.out.println(i);

3.2.7 死循环

1. 死循环

   • 可以一直执行下去的一种循环，如果没有干预不会停下来。

2. 死循环的写法

for( ; ; ){
    System.out.println("HelloWorld");
}

//经典写法
while(true){
    System.out.println("HelloWorld");
}

do{
    System.out.printin("HelloWorld");
}while(true);

1. 死循环案例

package com.itheima.f_dead;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:

/*
    死循环:可以一直执行下去的一种循环，如果没有干预不会停下来。

    本质上就是让判断条件一直成立
*/
public class Demo01 {
    public static void main(String[] args) {
        //需求1: for实现死循环
//        for( ; ; ){
//            System.out.println("HelloWorld!!!");
//        }

        //需求2: while实现死循环
//        while(true){
//            System.out.println("HelloWorld2!!!");
//        }
        //需求3: do-while实现死循环
        do {
            System.out.println("HelloWorld3!!!");
        } while (true);
    }

}

3.2.8 循环嵌套

1. 循环嵌套

   • 循环中又包含循环。

   for(int i = 0; i < 3; i++) { //一共说3天
   
        for(int j = 0; j < 5; j++) {
            System.out.println("我爱你");//每天说5遍
    }
   

2. 循环嵌套的特点

   • 外部循环每循环一次，内部循环会全部执行完一轮。

3. 循环嵌套案例

package com.itheima.g_nest;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 */

/*
    嵌套循环:
        循环中又包含循环的写法
    特点:
        外层循环执行1次, 内存循环执行1轮
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 连续说3天, 每天说5遍"我爱你"

//        for(int i=0;i<15;i++){
//            System.out.println("我爱你");
//        }

        //需求2: 连续说3天, 每天说5遍"我爱你"; 打印结果如下
        //第1天第1遍:我爱你
        //第1天第2遍:我爱你
        //...
        //第3天第5遍:我爱你
        for (int i = 1; i < 4; i++) {
            for (int j = 1; j < 6; j++) {
                System.out.println("第"+i+"天第"+j+"遍:我爱你");
            }
        }

        System.out.println("-------分割线--------");

        //需求3: 在控制台打印4行5列的矩形
        for(int i=0;i<4;i++){
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

3.3 跳转关键字: break、continue

3.3.1 跳转关键字: break、continue 详情

1. 跳转关键字
   • break: 跳出并结束当前所在循环的执行。
   • continue: 用于跳出当前循环的当次执行，直接进入循环的下一次执行。
2. 注意事项:
   • break : 只能用于结束所在循环, 或者结束所在switch分支的执行。
   • continue : 只能在循环中进行使用。
3. break、continue入门案例

package com.itheima.h_break_continue;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:

/*
跳转关键字
    break: 用于循环和switch,作用是结束
    continue: 仅用于循环, 作用是跳过本次, 继续下次
 */
public class Demo01 {
    public static void main(String[] args) {
        int i=1;
        while(true){
            if(i<10){
                break;
            }
            i++;
        }
        System.out.println("while循环以退出");

        for(int j=0;j<5;j++){
            if(j==4){
                System.out.println("当j="+j+" ,本次循环跳过.");
            }
        }

    }
}

3.3.2 案例: 密码验证

1. 需求：

   • 系统密码是520，请用户不断的从键盘输入密码进行验证
   • 验证不对输出：密码错误, 然后继续让用户输入
   • 验证成功输出：欢迎进入系统, 并停止程序。

2. 分析：

   • 定义一个键盘对象
   • 定义一个整型变量记录从键盘上接到的密码
   • 使用while死循环，让用户不断输入数据，与正确密码比对
   • 验证不成功输出：密码错误
   • 验证成功输出：欢迎进入系统，并使用break结束当前循环的执行。

package com.itheima.h_break_continue;

import java.util.Scanner;

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 *
/*

/*
 * 跳转关键字
 * break: 用于循环和switch,作用是结束
 * continue: 仅用于循环, 作用是跳过本次, 继续下次
 */

public class Demo02 {
    public static void main(String[] args) {
        //需求: 用户密码校验
        // 系统密码是520，请用户不断的从键盘输入密码进行验证
        // 验证不对输出：密码错误, 然后继续让用户输入
        int passWord = 520, inputPassWord = 0;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("请输入密码: ");
            inputPassWord = sc.nextInt();
            if (passWord == inputPassWord) {
                break;
            } else {
                System.out.print("密码错误, ");
            }
        }
        System.out.println("密码正确, 系统登陆成功!!!");

    }
}

3.4 Random类: 生成随机数

3.4.1 Random类 详情

1. 应用场景
   • 随机点名
   • 年会抽奖
2. Random类
   • 作用：生成随机数。
3. 得到0-9的随机数的实现步骤：
   • 导包：告诉程序去JDK的哪个包中找Random
   • 写一行代码拿到随机数对象
   • 调用随机数的功能获取0-9之间的随机数
4. 注意：
   • nextInt(n) 功能只能生成: 0 至 n-1之间的随机数，不包含n。

• 

1. 小练习:

package com.itheima.i_random;

import java.util.Random;
/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 *
/*

/*
    Random:生成随机数
    使用步骤
        1. 导包(IDEA会自动完成)
        2. 创建Random对象  Random r = new Random()
        3. 调用方法,获取结果 r.nextInt(n)
            此方法可以获取[0,n-1]之间的随机整数, 注意: 没有n
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建随机数对象
        Random r = new Random();
        //需求1: 获取一个[0,9]的随机整数
        int number = r.nextInt();
        System.out.println("随机生成[0,9]的随机整数为: "+ number);

        //需求2: 随机生成[1,10]之间的随机数，程序怎么实现？
        number=r.nextInt(10)+1;
        System.out.println("随机生成[1,10]之间的随机数为: "+ number);

        //需求3: 随机生成[33,55]之间的随机数，程序怎么实现？
        number= r.nextInt(23)+33;
        System.out.println("随机生成[33,55]之间的随机数为: "+ number);

        //规律: (大数-小数+1)+小数

    }
}

3.4.2 案例: 猜数字游戏

1. 需求：

   • 随机生成一个1-100之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束游戏。

2. 分析：

   • 先随机生成一个1-100之间的数据。
   • 定义一个死循环让用户可以一直猜测。
   • 在死循环里，每次都提示用户输入一个猜测的数字，猜大提示过大，猜小提示过小，猜中则结束游戏。

3. 详细代码:

package com.itheima.i_random;

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

/**
 * @author: LXHYouth
 * @date: 2024/3/3 11:39
 * @description:
 *
/*

/*
案例:猜数字
    随机生成一个1-100之间的数据，提示用户去猜测，
    用户从键盘输入猜测的数
    程序判断: 猜大提示过大，猜小提示过小，直到猜中结束游戏。
 */
public class Demo02 {
    public static void main(String[] args) {
        //思路:
        //1. 创建Random对象
        Random random = new Random();
        //2. 创建键盘对象
        Scanner scanner = new Scanner(System.in);
        //3. 生成随机数
        int number = random.nextInt(100) + 1;
        //4. 提示用户, 输入猜数字
        System.out.print("请输入猜测的数字: ");

        //5. 使用while死循环, 实现输入错误进行重新输入
        while (true) {
            int inputNumber = scanner.nextInt();
            if (inputNumber > number) {
                System.out.println("输入的数字大了, 请重新输入: ");
            } else if (inputNumber < number) {
                System.out.println("输入的数字小了, 请重新输入: ");
            } else {
                //6. 如果猜对, 使用答对了, 使用break终止循环.
                System.out.println("恭喜你猜对了");
                break;
            }
        }
        System.out.println("游戏到此结束, 谢谢参与!!!");

    }

}

3.4.3 总结

1. Random生成随机数需要几步？

   • 导包：import java.util.Random;
   • Random r = new Random();
   • int number = r.nextInt(10);

2. 如何生成 小数 – 大数 之间的随机数？

   • int number = r.nextInt(大数-小数+1) + 小数;