[Java知识库]26-Java案例技术：Random类、猜数字游戏

一、Random随机数技术

• 用于在程序中获取随机数的技术

1、使用步骤

• 导包：告诉程序去JDK的哪个包中找随机数技术

  import java.util.Random;
  

• 写一行代码代表得到随机数对象

  Random rd = new Random();
  

• 调用随机数的功能获取0-9的随机数

  int number = rd.nextInt(10);
  

package com.app.random;

// 1.导包：IDEA工具很方便，不需要我们手动写，自动导入的
import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用Java提供的随机数类Random

        // 2.创建随机数对象
        Random random = new Random();

        // 3.调用随机数的功能获取0-9的随机数
        int number = random.nextInt(10);

        // 4.输出生成的随机数
        System.out.println("生成的随机数：" + number);
    }
}

输出结果：

生成的随机数：7

要想看到0-9生成的更多随机数，可以使用循环来依次输出

package com.app.random;

// 1.导包：IDEA工具很方便，不需要我们手动写，自动导入的
import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用Java提供的随机数类Random

        // 2.创建随机数对象
        Random random = new Random();

        for (int i = 1; i <= 20; i++) {		// 要想看到0-9生成的更多随机数，需要循环取出
            // 3.调用随机数的功能获取0-9的随机数
        	int number = random.nextInt(10);

            // 4.输出生成的随机数
            System.out.println("第"+ i +"次生成的随机数：" + number);
        }
    }
}

输出结果：

第1次生成的随机数：0
第2次生成的随机数：9
第3次生成的随机数：8
第4次生成的随机数：6
第5次生成的随机数：9
第6次生成的随机数：6
第7次生成的随机数：4
第8次生成的随机数：1
第9次生成的随机数：8
第10次生成的随机数：7
第11次生成的随机数：4
第12次生成的随机数：8
第13次生成的随机数：9
第14次生成的随机数：2
第15次生成的随机数：5
第16次生成的随机数：7
第17次生成的随机数：5
第18次生成的随机数：1
第19次生成的随机数：2
第20次生成的随机数：2

• 注意：nextInt(n) 功能只能生成：0 至 n-1 之间的随机数，不包含n本身

2、Random生成随机数的特点

• nextInt(n) 功能只能生成：0 - (n-1) 之间的随机数

3、Random生成区间随机数的技巧：减加法

• 例如：要生成 1-10 之间的随机数，程序怎么实现？

package com.app.random;

// 1.导包：IDEA工具很方便，不需要我们手动写，自动导入的
import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用Java提供的随机数类Random

        // 2.创建随机数对象
        Random random = new Random();

//        for (int i = 1; i <= 20; i++) {  // 要想看到0-9生成的更多随机数，需要循环取出
//            // 3.调用随机数的功能获取0-9的随机数
//            int number = random.nextInt(10);
//
//            // 4.输出生成的随机数
//            System.out.println("第"+ i +"次生成的随机数：" + number);
//        }

        System.out.println("Random生成区间随机数的技巧（减加法）的使用");
        System.out.println("---------生成 1-10 之间的随机数---------");
        for (int i = 1; i <= 10; i++) {
            // 1-10 ==> -1 ==> (0-9) + 1
            int number = random.nextInt(10) + 1;
            System.out.println("第" + i + "次生成的随机数：" + number);
        }

        System.out.println("---------生成 6-19 之间的随机数---------");
        for (int i = 1; i <= 13; i++) {
            // 6-19 ==> -6 ==> (0-13) + 6
            int number = random.nextInt(14) + 6;
            System.out.println("第" + i + "次生成的随机数：" + number);
        }
    }
}

输出结果：

Random生成区间随机数的技巧（减加法）的使用
---------生成 1-10 之间的随机数---------
第1次生成的随机数：8
第2次生成的随机数：4
第3次生成的随机数：1
第4次生成的随机数：5
第5次生成的随机数：9
第6次生成的随机数：3
第7次生成的随机数：5
第8次生成的随机数：5
第9次生成的随机数：3
第10次生成的随机数：10
---------生成 6-19 之间的随机数---------
第1次生成的随机数：16
第2次生成的随机数：15
第3次生成的随机数：19
第4次生成的随机数：7
第5次生成的随机数：6
第6次生成的随机数：7
第7次生成的随机数：14
第8次生成的随机数：18
第9次生成的随机数：18
第10次生成的随机数：6
第11次生成的随机数：11
第12次生成的随机数：19
第13次生成的随机数：10

随机数总结

1、Random随机数类生成需要几步，具体是什么样的？

• 先导包：告诉程序去JDK哪个包找随机数类
• 写一行代码代表得到随机数对象
• 调用随机数的功能获取随机数，如：0-9、1-10、9-100、…

2、Random随机数如何生成 65-91 之间的随机数？

package com.app.random;

// 1.导包：告诉程序去JDK的哪个包找随机数对象：IDEA工具会自动导入，不需要手动操作
import java.util.Random;

public class RandomDemo2 {
    public static void main(String[] args) {
        // Random随机数如何生成 65-91 之间的随机数？ 用随机数技巧：减加法解决——> 65-91 ==> -65 ==> (0-26) + 65

        // 2.写一行代码代表得到随机数对象Random
        Random rd = new Random();

        // 3.定义for循环
        for (int i = 1; i <= 26; i++) {     // 65-91之间有26个随机数
            // 4.在循环内调用随机数功能获取65-91的随机数，使用随机数生成技巧：减加法实现
            // 65-91 ==> -65 ==> (0-26) + 65
            int number = rd.nextInt(27) + 65;
            // 5.循环输出65-91之间生成的所有随机数
            System.out.println("第" + i + "次生成的随机数：" + number);
        }
    }
}

输出结果：
第1次生成的随机数：79
第2次生成的随机数：88
第3次生成的随机数：77
第4次生成的随机数：79
第5次生成的随机数：70
第6次生成的随机数：75
第7次生成的随机数：70
第8次生成的随机数：83
第9次生成的随机数：82
第10次生成的随机数：79
第11次生成的随机数：73
第12次生成的随机数：68
第13次生成的随机数：69
第14次生成的随机数：86
第15次生成的随机数：91
第16次生成的随机数：65
第17次生成的随机数：80
第18次生成的随机数：71
第19次生成的随机数：87
第20次生成的随机数：65
第21次生成的随机数：91
第22次生成的随机数：75
第23次生成的随机数：71
第24次生成的随机数：73
第25次生成的随机数：69
第26次生成的随机数：88

二、随机数案例：猜数字游戏

• 需求：

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

• 分析：

  • 1、随机生成一个1-100之间的数据
    • 1-100 ==> -1 ==> (0-99) + 1
    • (1-1) 先导包：随机数对象(Random)、扫描器对象(Scanner)
    • (1-2) 创建随机数对象(用于获取随机数)、扫描器对象(用于用户输入随机数)
    • (1-3) 调用随机数功能获取1-100之间的随机数
  • 2、使用死循环让用户不断猜测随机数，猜大了提示过大，猜小了提示过小，猜中结束游戏
    • (2-1) 使用while循环，条件为true，形成死循环
    • (2-2) 在while循环内，接收用户输入的随机数
    • (2-3) 接着使用if判断：
    • (2-4) 当用户输入的随机数 <= 0 或 > 100时，提示：“输入有误！”;
    • (2-5) 当用户输入的随机数 == 获取的随机数时，提示：“恭喜您，猜中了~”，游戏结束（使用break跳出循环的执行）.
    • (2-6) 当用户输入的随机数 > 获取的随机数时，提示：“很遗憾，数大了~”;
    • (2-7) 当用户输入的随机数 < 获取的随机数时，提示：“很遗憾，数小了~”;
    • (2-8) break跳出循环的执行后，提示：“游戏结束！”

  package com.app.random;
  
  // (1-1) 先导包：随机数对象(Random)、扫描器对象(Scanner)————>创建它们的对象类时，IDEA会自动导入
  
  import java.util.Random;
  import java.util.Scanner;
  
  public class RandomTest3 {
      public static void main(String[] args) {
          // 目标：通过随机数案例：猜数字游戏，更深入理解随机数
          /*
              一、需求：
                  随机生成一个1-100之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束游戏
              二、分析：
                  1、随机生成一个1-100之间的数据
                      1-100 ==> -1 ==> (0-99) + 1
                      (1-1) 先导包：随机数对象(Random)、扫描器对象(Scanner)————>创建它们的对象类时，IDEA会自动导入
                      (1-2) 创建随机数对象(用于获取随机数)、扫描器对象(用于用户输入随机数)
                      (1-3) 调用随机数功能获取1-100之间的随机数
                  2、使用死循环让用户不断猜测随机数，猜大了提示过大，猜小了提示过小，猜中结束游戏
                      (2-1) 使用while循环，条件为true，形成死循环
                      (2-2) 在while循环内，接收用户输入的随机数
                      (2-3) 接着使用if判断：
                      (2-4) 当用户输入的随机数 <= 0 或 > 100时，提示："输入有误！";
                      (2-5) 当用户输入的随机数 == 获取的随机数时，提示："恭喜您，猜中了~"，游戏结束（使用break跳出循环的执行）.
                      (2-6) 当用户输入的随机数 > 获取的随机数时，提示："很遗憾，数大了~";
                      (2-7) 当用户输入的随机数 < 获取的随机数时，提示："很遗憾，数小了~";
                      (2-8) break跳出循环的执行后，提示："游戏结束！"
           */
          // 1、随机生成一个1-100之间的数据
          // (1-2) 创建随机数对象(用于获取随机数)、扫描器对象(用于用户输入随机数)
          Random rd = new Random();               // 随机数对象
          Scanner sc = new Scanner(System.in);    // 扫描器对象
  
          // (1-3) 调用随机数功能获取1-100之间的随机数
          // 1-100 ==> -1 ==> (0-99) + 1
          int rdNumber = rd.nextInt(100) + 1;
  
  
  
          // 2、使用死循环让用户不断猜测随机数，猜大了提示过大，猜小了提示过小，猜中结束游戏
          // (2-1) 使用while循环，条件为true，形成死循环
          while (true) {
              // (2-2) 在while循环内，接收用户输入的随机数
                  System.out.println("答案是（显示答案方便测试）：" + rdNumber);
                  System.out.println("请您随便猜个数(1~100)：");
                  int data = sc.nextInt();
              // (2-3) 接着使用if判断
              if (data <= 0 || data > 100) {     // (2-4) 当用户输入的随机数 <= 0 或 > 100时，
                  // 提示："输入有误！";
                  System.out.println("输入有误！\n");
  
              } else if (data == rdNumber) {      // (2-5) 当用户输入的随机数 == 获取的随机数时，
                  // 提示："恭喜您，猜中了~"，
                  System.out.println("恭喜您，猜中了~\n");
                  // 游戏结束. ——> 使用break跳出当前循环的执行
                  break;
  
              } else if (data > rdNumber) {  // (2-6) 当用户输入的随机数 > 获取的随机数时，
                  // 提示："很遗憾，数大了~";
                  System.out.println("很遗憾，数大了~\n");
  
              } else {    //  (2-7) 当用户输入的随机数 < 获取的随机数时，
                  // 提示："很遗憾，数小了~";
                  System.out.println("很遗憾，数小了~\n");
              }
          }
          // (2-8) break跳出循环的执行后，提示："游戏结束！"
          System.out.println("游戏结束！");
      }
  }
  

  输出结果：
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  0
  输入有误！
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  -1
  输入有误！
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  101
  输入有误！
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  150
  输入有误！
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  35
  很遗憾，数小了~
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  37
  很遗憾，数大了~
  
  答案是（显示答案方便测试）：36
  请您随便猜个数(1~100)：
  36
  恭喜您，猜中了~
  
  游戏结束！