【JavaSE】程序逻辑控制

￡神魔★判官ぃ 2024-03-17 13:40 55阅读 0赞

**目录**

【1】概念

【2】顺序结构

【3】分支结构

【3.1】if 语句

【3.2】switch 语句

【4】循环结构

【4.1】while 循环

【4.2】for 循环

【4.3】do while 循环

【4.4】break 关键字

【4.5】continue 关键字

【5】输入输出

【5.1】输出到控制台

【5.2】从键盘输入

【6】猜数字游戏

--------------------

## **【1】概念** ##

**我的曾经：**

早上8:00起床-->洗漱-->吃早饭-->上课-->吃午饭-->上课-->运动-->吃完饭-->玩手机-->睡觉每天的生活貌似都是这么规律，顺序的做着每件事，前途一片渺茫~~~

**我的曾经：**

早上8:00起床-->洗漱-->吃早饭-->上课-->吃午饭-->上课-->运动-->吃完饭-->玩手机-->睡觉 每天的生活貌似都是这么规律，顺序的做着每件事，前途一片渺茫~~~

就这样**日复一日的努力**着，感觉每天都很充实，生活看到了希望~~~

![e8628024b97741ff98c246706f69e2c2.png][]

## **【2】顺序结构**  ##

顺序结构比较简单，按照代码书写的顺序一行一行执行。

System.out.println("aaa");
    System.out.println("bbb");
    System.out.println("ccc");
    
    // 运行结果
    aaa
    bbb
    ccc

如果调整代码的书写顺序, 则执行顺序也发生变化。

System.out.println("aaa");
    System.out.println("ccc");
    System.out.println("bbb");
    
    // 运行结果
    aaa
    ccc
    bbb

## **【3】分支结构**  ##

### **【3.1】if 语句**  ###

1.  语法格式1

if(布尔表达式){
    	// 语句
    }

如果布尔表达式结果为true，执行if中的语句，否则不执行。

比如：小明，如果这次考试考到90分或以上，给你奖励一个鸡腿。

int score = 92;
    if(score >= 90){
        System.out.println("吃个大鸡腿!!!");
    }

2. 语法格式2

if(布尔表达式){
    	// 语句1
    }else{
    	// 语句2
    }

如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。

比如：小明，如果这次考到90分以上，给你奖励一个大鸡腿，否则奖你一个大嘴巴子。

int score = 92;
    if(score >= 90){
    	System.out.println("吃个大鸡腿!!!");
    }else{
    	System.out.println("挨大嘴巴子!!!");
    }

3. 语法格式3

if(布尔表达式1){
    	// 语句1
    }else if(布尔表达式2){
    	// 语句2
    }else{
    	// 语句3
    }

表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

比如：考虑到学生自尊，不公开分数排名，因此：

*  分数在 \[90, 100\] 之间的，为优秀
 *  分数在 \[80, 90) 之前的，为良好
 *  分数在 \[70, 80) 之间的，为中等
 *  分数在 \[60, 70) 之间的，为及格
 *  分数在 \[ 0, 60) 之间的，为不及格
 *  错误数据。

按照上述办法通知学生成绩。

public static void main(String[] args) {
        int score = 100;
        if (score >= 90)
            System.out.println("优秀");
        else if (score >= 80 && score < 90)
            System.out.println("良好");
        else if (score >= 70 && score < 80)
            System.out.println("中等");
        else if (score >= 60 && score < 70)
            System.out.println("及格");
        else if (score >= 0 && score < 60)
            System.out.println("不及格");
        else {
            System.out.println("错误数据");
        }
    }

【**练习**】

1.  判断一个数是基数还是偶数。

public static void main(String[] args) {
        // Scanner：工具   new：创建一个对象   System.in：从键盘输入
        Scanner scanner = new Scanner(System.in);
        
        // scanner.nextInt() -> 接受整型值。
     	int iVal = scanner.nextInt();
        if(iVal % 2 == 0)
            System.out.println("iVal是偶数");
        else
            System.out.println("iVal是奇数");
    }

1.  判断一个数字是正数，负数，还是零。

public static void main(String[] args) {
        // Scanner：工具   new：创建一个对象   System.in：从键盘输入
        Scanner scanner = new Scanner(System.in);
        
        // scanner.nextInt() -> 接受整型值。
        int iVal = scanner.nextInt();
        if(iVal > 0)
            System.out.println("正数");
        else
            System.out.println("负数");
    }

1.  判断一个年份是否为闰年。

public static void main(String[] args) {
        // Scanner：工具   new：创建一个对象   System.in：从键盘输入
        Scanner scanner = new Scanner(System.in);
        
        // 判断闰年的公式：
        //（1）四年一闰百年不闰：即如果year能够被4整除，但是不能被100整除，则year是闰年。
        //（2）每四百年再一闰：如果year能够被400整除，则year是闰年。
        // scanner.nextInt() -> 接受整型值。
        int iVal = scanner.nextInt();
        for (int year = 1000; year < iVal; year++)  {
            if ((year % 4 == 0) && (year % 100 != 0))
                System.out.println(year + "->是闰年");
            else if (year % 400 == 0)
                System.out.println(year + "->是闰年");
            else
                System.out.println(year + "->不是闰年");
        }
    }

**【注意事项】**

*  代码风格

// 风格1-----> 推荐
    int x = 10;
    if (x == 10) {
    	// 语句1
    } else {
    	// 语句2
    } 
    
    // 风格2
    int x = 10;
    if (x == 10)
    {
    	// 语句1
    } else 
    {
    	// 语句2
    }
    
    // 代码风格没有好坏，看个人的爱好。

虽然两种方式都是合法的, 但是 Java 中更推荐使用风格1, \{ 放在 if / else 同一行. 代码跟紧凑。

*  分号问题

int x = 20;
    if (x == 10);
    {
    	System.out.println("hehe");
    } 
    // 运行结果
    hehe

此处多写了一个 分号, 导致分号成为了 if 语句的语句体, 而 \{ \} 中的代码已经成为了和一个 if 无关的代码块。

*  悬垂 else 问题

int x = 10;
    int y = 10;
    if (x == 10)
    	if (y == 10)
    		System.out.println("aaa");
    else
    	System.out.println("bbb");

if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配. 但是实际开发中我们\*\* **不建议\***\* 这么写. 最好加上大括号。

### **【3.2】switch 语句**  ###

**【基本语法】**

switch(表达式){
        case 常量值1:{
            语句1;
            [break;]
        }
        case 常量值2:{
            语句2;
            [break;]
        }
        ...
        default:{
            内容都不满足时执行语句;
            [break;]
        }
    }

**【执行流程】**

*  先计算表达式的值。
 *  和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束。
 *  当表达式的值没有与所列项匹配时，执行default。

**【代码示例】** 根据 day 的值输出星期。

public static void main(String[] args) {
        // Scanner：工具   new：创建一个对象   System.in：从键盘输入
        Scanner scanner = new Scanner(System.in);
        
        // scanner.nextInt() -> 接受整型值。
        int iDay = scanner.nextInt();
        switch (iDay){
            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("数值错误");
        }
    }

【**注意事项**】

*  多个case后的常量值不可以重复。
 *  switch的括号内只能是以下类型的表达式 。
    
     *  基本类型：byte、char、short、int，注意不能是long类型。
     *  引用类型：String常量串、枚举类型 。

double num = 1.0;
    switch(num) {
        case 1.0:
            System.out.println("hehe");
            break;
        case 2.0:
            System.out.println("haha");
            break;
    }
    
    // 编译出错
    Test.java:4: 错误: 不兼容的类型: 从double转换到int可能会有损失
    	switch(num) {
    	^
    1 个错误

*  break 不要遗漏, 否则会失去 "多分支选择" 的效果

int day = 1;
    switch(day) {
        case 1:
            System.out.println("星期一");
            // break;
        case 2:
            System.out.println("星期二");
            break;
    }
    
    // 运行结果
    星期一
    星期二

*  switch 不能表达复杂的条件

// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
    // 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示.
    if (num > 10 && num < 20) {
    	System.out.println("hehe");
    }

*  switch 虽然支持嵌套, 但是很丑，一般不推荐~

int x = 1;
    int y = 1;
    switch(x) {
        case 1:
            switch(y) {
                case 1:
                    System.out.println("hehe");
                    break;
            }
            break;
        case 2:
            System.out.println("haha");
            break;
    }

代码的美观程度也是一个重要的标准. 毕竟这是**看脸的世界**。

![6b46eae3b59d42a8a86271a3a3983d7a.png][]

综上, 我们发现, switch 的使用局限性是比较大的。

## **【4】循环结构**  ##

### **【4.1】while 循环**  ###

**【基本语法】**

while(循环条件){ // 循环条件为 true, 则执行循环语句; 否则结束循环. 
    	循环语句;
    }

**【代码示例1】** 打印 1 - 10 的数字。

public static void main(String[] args) {
        int i = 1;
        while(i <= 10){
            System.out.println(i);
            i++;
        }
    }

**【代码示例2】** 在一个循环条件中计算 1 - 100 的和、1-100偶数的和、1-100奇数的和。

public static void main(String[] args) {
        int i = 1;
        int iSum = 0;
        int iEvenSum = 0;
        int iOddSum = 0;
        
        while(i <= 100){
            if (i % 2 == 0) { // 这里是偶数的和
                iEvenSum = iEvenSum + i;
            } else { // 这里是奇数的和
                iOddSum = iOddSum + i;
            }
            // 这里是1-100的和
            iSum = iSum + i;
            i++;
        }
        
        System.out.println("1-100和: " + iSum);
        System.out.println("1-100中偶数和: " + iEvenSum);
        System.out.println("1-100中奇数和: " + iOddSum);
    }

**【代码示例3】** 计算 5 的阶乘。

public static void main(String[] args) {
        int n = 1;
        int result = 1;
        while (n <= 5) {
            result *= n;
            n++;
        }
        
        System.out.println(result);
    }

**【代码示例4】** 计算 1! + 2! + 3! + 4! + 5!

/**
     * 求n的阶层函数
     * @param n 阶层的层数
     * @return 返回n的阶层
     */
    public static int StratumSum(int n) {
        // 定义结果值
        int result = 1;
        int i = 1;
        while (i <= n) {
            result *= i;
            i++;
        }
        // 返回n的阶层
        return result;
    }
    
    /**
     * 入口函数
     * @param args
     */
    public static void main(String[] args) {
        int n = 5;
        int retSum = 0;
        while (n > 0) {
            System.out.println(retSum);
            retSum = retSum + StratumSum(n);
            n--;
        }
        // 打印结果
        System.out.println(retSum);
    }
    
    
    // ----------------------------------------------------------------------------------
    
    /**
     * 入口函数
     * @param args
     */
    public static void main(String[] args) {
        int n = 5;
        int retSum = 0;
        while (n > 0) {
            // retSum = retSum + StratumSum(n);
            // 定义结果值
            int result = 1;
            int i = 1;
            while (i <= n) {
                result *= i;
                i++;
            }
            retSum = retSum + result;
            n--;
        }
        System.out.println(retSum);
    }

这里我们发现, 当一个代码中带有多重循环的时候, 代码的复杂程度就大大提高了. 而比较复杂的代码就更容易出错.后面我们会采用更简单的办法来解决这个问题。

**【注意事项】**

*  和 if 类似, while 下面的语句可以不写 \{ \} , 但是不写的时候只能支持一条语句. 建议还是加上 \{ \}。
 *  和 if 类似, while 后面的 \{ 建议和 while 写在同一行。
 *  和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行。

int num = 1;
    while (num <= 10); {
    	System.out.println(num);
    	num++;
    }
    
    // 执行结果
    [无任何输出, 程序死循环]

此时 ; 为 while 的语句体(这是一个空语句), 实际的 \{ \} 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码死循环了。

### **【4.2】for 循环**  ###

【**基本语法**】

for(表达式①;布尔表达式②;表达式③){
    	表达式④;
    }

*  表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次。
 *  表达式2: 循环条件，满则循环继续，否则循环结束。
 *  表达式3: 循环变量更新方式

【**执行过程**】

`①②③④--->②③④--->②③④--->②③④--->②③④--->②③④--->...--->②为false`，循环结束。

**【代码示例1】** 打印 1 - 10 的数字。

public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.print(i + " ");
        }
    }

**【代码示例2】** 在一个循环条件中计算 1 - 100 的和、1-100偶数的和、1-100奇数的和。

public static void main(String[] args) {
        int iSum = 0;
        int iSumEven = 0;
        int iSumOdd = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0)
                iSumEven = iSumEven + i;
            else
                iSumOdd = iSumOdd + i;
            iSum = iSum + 1;
        }
        
        System.out.println(iSum);
        System.out.println(iSumEven);
        System.out.println(iSumOdd);
    }

**【代码示例3】** 计算 5 的阶乘。

public static void main(String[] args) {
        int sum = 1;
        for (int i = 1; i <= 5; i++) {
            sum *= i;
        }
        
        System.out.println(sum);
    }

**【代码示例4】** 计算 1! + 2! + 3! + 4! + 5!

/**
     * 求n的阶层函数
     * @param n 阶层的层数
     * @return 返回n的阶层
     */
    public static int StratumSum(int n) {
        int ret = 1;
        for (int j = 1; j <= n; j++) {
            ret *= j;
        }
        return ret;
    }
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1; i <= 5; i++) {
            int ret = StratumSum(i);
            sum = sum + ret;
        }
        
        System.out.println(sum);
    }
    
    
    // ----------------------------------------------------------------------------------
    
    
    /**
     * 入口函数
     * @param args
     */
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1; i <= 5; i++) {
            int ret = 1;
            for (int j = 1; j <= i; j++) {
                ret *= j;
            }
            sum = sum + ret;
        }
        
        System.out.println(sum);
    }

**【注意事项】** (和while循环类似)

*  和 `if` 类似, `for` 下面的语句可以不写 `{ }` , 但是不写的时候只能支持一条语句. 建议还是加上 `{ }`。
 *  和 `if` 类似, `for` 后面的 `{` 建议和 `while` 写在同一行。
 *  和 `if` 类似, `for` 后面不要多写 分号, 否则可能导致循环不能正确执行。
 *  和while循环一样，结束单趟循环用`continue`，结束整个循环用`break`。

### **【4.3】do while 循环**  ###

**【基本语法】**

do{
    	循环语句;
    }while(循环条件);

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

例如：打印 1 - 10

int num = 1;
    do {
    	System.out.println(num);
    	num++;
    } while (num <= 10);

**【注意事项】**

*  `do while` 循环最后的分号不要忘记。
 *  一般 `do while` 很少用到, 更推荐使用 for 和 while。

### **【4.4】break 关键字** ###

`break` 的功能是让循环提前结束。

**代码示例:** 找到 100 - 200 中第一个 3 的倍数 。

public static void main(String[] args) {   // 针对其他的循环语句是一样的用法
        int begin = 100;
        while(begin <= 200){
            if(begin % 3  == 0) {
                break;
            }
            begin++;
        }
        System.out.println(begin);
    }
    
    // 执行结果：找到了 3 的倍数, 为:102

执行到 `break` 就会让循环结束。

### **【4.5】continue 关键字** ###

`continue` 的功能是跳过这次循环, 立即进入下次循环。

**代码示例:** 找到 100 - 200 中第一个 3 的倍数 。

public static void main(String[] args) {	// 针对其他的循环语句是一样的用法
        int begin = 100;
        while(begin <= 200){
            if(begin % 3  == 0) {
                continue;
            }
            begin++;
        }
        System.out.println(begin);
    }
    
    // 死循环begin++永远都不可能被执行。

执行到 `continue` 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句 。

## **【5】输入输出**  ##

### **【5.1】输出到控制台**  ###

System.out.println(msg); // 输出一个字符串, 带换行
    System.out.print(msg); // 输出一个字符串, 不带换行
    System.out.printf(format, msg); // 格式化输出

*  `println` 输出的内容自带 `\n`, `print` 不带 `\n`。
 *  `printf` 的格式化输出方式和 C 语言的 `printf` 是基本一致的 。

**【代码实例】**

public static void main(String[] args) {
        String msg = "傻响";
        System.out.println(msg);
        System.out.print(msg + "\n");
        System.out.printf("%s\n", msg);   
    }

**【格式化字符串 】**

<table> 
 <thead> 
  <tr> 
   <th style="vertical-align:bottom;">转换符</th> 
   <th style="vertical-align:bottom;">类型</th> 
   <th style="vertical-align:bottom;">举例</th> 
   <th style="vertical-align:bottom;"></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;">d</td> 
   <td style="vertical-align:top;">十进制整数</td> 
   <td style="vertical-align:top;">("%d", 100)</td> 
   <td style="vertical-align:top;">100</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">x</td> 
   <td style="vertical-align:top;">十六进制整数</td> 
   <td style="vertical-align:top;">("%x", 100)</td> 
   <td style="vertical-align:top;">64</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">o</td> 
   <td style="vertical-align:top;">八进制整数</td> 
   <td style="vertical-align:top;">("%o", 100)</td> 
   <td style="vertical-align:top;">144</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">f</td> 
   <td style="vertical-align:top;">定点浮点数</td> 
   <td style="vertical-align:top;">("%f", 100f)</td> 
   <td style="vertical-align:top;">100.000000</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">e</td> 
   <td style="vertical-align:top;">指数浮点数</td> 
   <td style="vertical-align:top;">("%e", 100f)</td> 
   <td style="vertical-align:top;">1.000000e+02</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">g</td> 
   <td style="vertical-align:top;">通用浮点数</td> 
   <td style="vertical-align:top;">("%g", 100f)</td> 
   <td style="vertical-align:top;">100.000</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">a</td> 
   <td style="vertical-align:top;">十六进制浮点数</td> 
   <td style="vertical-align:top;">("%a", 100)</td> 
   <td style="vertical-align:top;">0x1.9p6</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">s</td> 
   <td style="vertical-align:top;">字符串</td> 
   <td style="vertical-align:top;">("%s", 100)</td> 
   <td style="vertical-align:top;">100</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">c</td> 
   <td style="vertical-align:top;">字符</td> 
   <td style="vertical-align:top;">("%c", ‘1’)</td> 
   <td style="vertical-align:top;">1</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">b</td> 
   <td style="vertical-align:top;">布尔值</td> 
   <td style="vertical-align:top;">("%b", 100)</td> 
   <td style="vertical-align:top;">true</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">h</td> 
   <td style="vertical-align:top;">散列码</td> 
   <td style="vertical-align:top;">("%h", 100)</td> 
   <td style="vertical-align:top;">64</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">%</td> 
   <td style="vertical-align:top;">百分号</td> 
   <td style="vertical-align:top;">("%.2f%%", 2/7f)</td> 
   <td style="vertical-align:top;">0.29%</td> 
  </tr> 
 </tbody> 
</table>

这个表格没必要记住, 用到的时候根据需要查一下就行了。

### **【5.2】从键盘输入**  ###

**【实例代码】**使用 Scanner 读取字符串/整数/浮点数。

import java.util.Scanner; // 需要导入 util 包
    
    
    // 问题一：
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入姓名:> ");
        
        // No.1 如果是next那么读取是会碰到空格就结束.
        String name = scanner.next();
        // 打印结果：
        请输入姓名:> Sha Xiang
    	姓名: Sha
        
        // No.2 nextLine会读取一行.
        String name = scanner.nextLine();
        // 打印结果：
        请输入姓名:> Sha Xiang
    	姓名: Sha Xiang
        
        System.out.println("姓名: " + name + "," + "年龄: ");
        scanner.close();
    }
    
    // 问题二：
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 先读取年龄(整型)
        System.out.print("请输入年龄:> ");
        int age = scanner.nextInt();
        
        // 如果先读取的是整数、浮点数，没有先读取字符串，就需要这样处理掉隐藏的'\n'，否则下面的			就会失效。
    	scanner.nextLine(); 
    	// 最后读取名字(字符串)
        System.out.print("请输入姓名:> ");
        String name = scanner.nextLine();
    
    
        System.out.println("姓名: " + name + "," + "年龄: " + age);
        scanner.close();
    }
    
    // ----------------------------------------------------------------------------------
    
    // 正常的代码：
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 这样的顺序是没问题的-》先处理字符串√
        System.out.print("请输入姓名:> ");
        String name = scanner.nextLine();
        
        System.out.print("请输入年龄:> ");
        int age = scanner.nextInt();
        
        System.out.print("请输入工资:> ");
        double salary = scanner.nextDouble();
        
        System.out.println("姓名: " + name + "," + "年龄: " + age + "," + "工资: " + salary + "元");
        scanner.close();
    }
    // 打印结果：
    // 请输入姓名:> 傻响
    // 请输入年龄:> 18
    // 请输入工资:> 
    // 22.12
    // 姓名: 傻响,年龄: 18,工资: 22.12

**【实例代码】**使用 Scanner 循环读取 N 个数字，并求取其平均值。

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int sum = 0;
        int cnt = 0;
        
        // scan.hasNextInt()
        // 如果此扫描仪输入中的下一个标记可以使用nextInt()方法解释为指定基数中的int值，则返回true。 扫描仪不会超过任何输入。 
        // 当且仅当此扫描器的下一个令牌是有效的int值时才为真 
        while(scan.hasNextInt()) {  // Ctrl + d程序会自己结束掉.
            sum += scan.nextInt();
            cnt++;
        }
        
        System.out.println("总和: " + sum);
        System.out.println("平均值: " + sum / cnt);
        scan.close();
    }

**注意事项:** 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl + d) , 在后续oj题当中，遇到IO类型的算法题，有各种循环输入的要求，后序给大家介绍。

## **【6】猜数字游戏**  ##

**【游戏规则】**

系统自动生成一个随机整数(1-100), 然后由用户输入一个猜测的数字. 如果输入的数字比该随机数小, 提示 "低了", 如果输入的数字比该随机数大, 提示 "高了" , 如果输入的数字和随机数相等, 则提示 "猜对了" 。

**【参考代码】**

public static void main(String[] args) {
        // new随机数对象
        Random random = new Random();
        // 给出随机数
        int randomNumber = random.nextInt(100) + 1; // 【0 - 99】 + 1 = 【0 - 100】
        Scanner scan = new Scanner(System.in);
        
        // 进入死循环开始猜数字
        int cnt = 1;
        while(true) {
            System.out.println("第" + cnt + "次>请输入猜测的数字:> ");
            cnt++;
            
            int input = scan.nextInt();
            if(input > randomNumber){
                System.out.println("猜大了");
                continue;
            } else if (input < randomNumber) {
                System.out.println("猜小了");
                continue;
            } else {
                System.out.println("猜中了");
                break;
            }
        }
        scan.close();
    }

[e8628024b97741ff98c246706f69e2c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b2cd4f48d78145f3a40b808d883daaa5.png
[6b46eae3b59d42a8a86271a3a3983d7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/721f4a98ff1c4a47a46471272f14b43a.png