瓜瓜头条

003-Java程序流程控制

2024-03-04 21:40 由 LXHYouth 发表于 #后端开发

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) + 小数;

热门相关：万古第一帝   龙组使命   绝代疯少   走私大明   铁血大明