Java运算符及程序逻辑控制

engrave行而不辍

已于 2024-05-30 16:29:50 修改

阅读量1k

点赞数 20

文章标签： java 开发语言

于 2024-05-30 15:37:54 首次发布

本文链接：https://blog.csdn.net/2301_80046330/article/details/139324474

版权

在这里插入图片描述

🎉welcome to my blog
请留下你宝贵的足迹吧(点赞👍评论📝收藏⭐）
💓期待你的一键三连，你的鼓励是我创作的动力之源💓

🍀运算符

运算符即对操作数进行操作时的符号，不同运算符操作的含义不同

Java中运算符可分为：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等

📚1.算术运算符

📖1.1基本四则运算符

加减乘除模(+ - * / %)

int a = 20;
int b = 10;
 
System.out.println(a + b);     // 30
System.out.println(a - b);     // 10
System.out.println(a * b);     // 200
System.out.println(a / b);     // 2
System.out.println(a % b);     // 0 --->模运算相当于数学中除法的余数

注意📚：

🍃都是二元运算符，使用时必须要有左右两个操作数

🍃int / int 结果还是int类型，而且会向下取整

int a = 3;
int b = 2;
System.out.println(a / b);
//在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
// 如果要得到数学中的结果，可以使用如下方式
double d = a*1.0 / b;
System.out.println(d);

🍀做除法和取模时，右操作数不能为0

int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:5)

🍀% 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

System.out.println(11.5 % 2.0);
// 运行结果
1.5

🍀两侧操作数类型不一致时，向类型大的提升

System.out.println(1+0.2);   // +的左侧是int，右侧是double，在加之前int被提升为double
                             // 故：输出1.2

📖1.2增量运算符

+= -= *= %=

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数

int a = 1;
a += 2;                  // 相当于 a = a + 2
System.out.println(a);   // 输出3
 
a -= 1;                  // 相当于 a = a - 1
System.out.println(a);   // 输出2
 
a *= 3;                  // 相当于 a = a * 3
System.out.println(a);   // 输出6
 
a /= 3;                  // 相当于 a = a / 3
System.out.println(a);   // 输出2
 
a %= 3;                  // 相当于 a = a % 2
System.out.println(a);   // 输出2

long b=3;
//a=a+b;//a+b为long类型，a为int类型，故此处会报错
//若写成如下形式就不会报错了
a+=b;                     
System.out.println(a);    // 输出4

注意👀： 只有变量才能使用该运算符，常量不能使用

📖1.3自增/自减运算符

++是给变量的值+1，–是给变量的值-1

int a = 1;
a++;    // 后置++   表示给a的值加1，此时a的值为2
System.out.println(a++);   // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a);     // 输出3
 
 
++a;    // 前置++   表示给a的值加1
System.out.println(++a);   // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a);     // 输出5
 
// --操作符给操作-1，与++含义类似

注意📖：

🌈如果单独使用，【前置++】和【后置++】没有任何区别

🌈如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1

🌈只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

📚2.关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
//     在Java中 == 表示相等
System.out.println(a == b);       // false
System.out.println(a != b);       // true
System.out.println(a < b);        // true
System.out.println(a > b);        // false
System.out.println(a <= b);       // true
System.out.println(a >= b);       // false

**注意⚠️：**当需要多次判断时，不能连着写，比如：3 < a < 5，true/false不能和5比较大小

📚3.逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型

📖3.1逻辑与 &&

🌟语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果

🌟相当于现实生活中的且

🌟两个表达式都为真，结果才为真，只要有一个为假，结果就为假

int a = 1;
int b = 2;

System.out.println(a == 1 && b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100);  // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2);  // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

📖3.2逻辑或 ||

🌲语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果

🌲相当于现实生活中的或

🌲若结果为真，则左右表达式至少有一个为真

int a = 1;
int b = 2;
 
System.out.println(a == 1 || b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100);  // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2);  // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

📖3.3逻辑非 !

🌴语法规则：! 表达式

🌴真变假，假变真。

int a = 1;
System.out.println(!(a == 1));   // a == 1 为true，取个非就是false
System.out.println(!(a != 1));  // a != 1 为false，取个非就是true

📖3.4短路求值

&& 和 || 遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0);             // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0);             // 打印 true

计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

注意📚:

🍃对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.

🍃对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.

🍃& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

System.out.println(10 > 20 & 10 / 0 == 0);             // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0);             // 程序抛出异常
System.out.println(10 > 20 & 10>0);                    //false
System.out.println(10 < 20 & 10>0);                    //true

📚4.位运算符

Java中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据

位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符

位操作表示按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算

📖4.1按位与 &

如果两个二进制位都是1, 则结果为1, 否则结果为 0

int a = 10;
int b = 20;
System.out.println(a & b);

进行按位运算, 需要先把10和20转化成二进制, 分别为1010和10100

📖4.2按位或 |

如果两个二进制位都是0, 则结果为0, 否则结果为1

int a = 10;
int b = 20;
System.out.println(a | b);

运算方式和按位于类似:

注意📒:

当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.

📖4.3按位取反 ~

如果该位为0 则转为1, 如果该位为1 则转为0

int a = 0xf;
System.out.printf("%x\n", ~a)

注意📚:

🌴0x 前缀的数字为十六进制数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应4 个二进制位.

🌴0xf 表示10进制的15, 也就是二进制的1111

🌴printf 能够格式化输出内容, %x 表示按照十六进制输出

🌴\n 表示换行符

📖4.4按位异或 ^

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);

注意👀： 如果两个数相同，则异或的结果为0

📚5.移位运算

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的

📖5.1左移 <<

最左侧位不要了, 最右侧补 0

int a = 0x10;//十六进制0x10，对应十进制为16，二进制为00010000
System.out.printf("%x\n", a << 1);//左移最左侧位不要了, 最右侧补0,得二进制00100000，对应十进制32，十六进制0x20
 
// 运行结果(注意, 是按十六进制打印的)
20

注意📚： 向左移位时，丢弃的是符号位，因此正数左移可能会变成负数

📖5.2右移 >>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10;//十六进制0x10，对应十进制为16，二进制为00010000
System.out.printf("%x\n", a >> 1);//右移最右侧位不要了, 最左侧补符号位(正数补0, 负数补1),得二进制00001000,对应十进制8，十六进制0x8
 
// 运行结果(注意, 是按十六进制打印的)
8
    
int b = 0xﬀﬀ0000;
System.out.printf("%x\n", b >> 1);
 
// 运行结果(注意, 是按十六进制打印的)
ﬀﬀ8000

📖5.3无符号右移 >>>

最右侧位不要了, 最左侧补0.

int a = 0xﬀﬀﬀﬀ;
System.out.printf("%x\n", a >>> 1);
 
// 运行结果(注意, 是按十六进制打印的)
7fﬀﬀﬀ

注意📖:

左移 1 位, 相当于原数字 *2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
移动负数位或者移位位数过大都没有意义.

📚6.条件运算符

条件运算符只有一个: 表达式1 ? 表达式2 : 表达式3

当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;

当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

也是 Java 中唯一的一个三目运算符, 是条件判断语句的简化写法.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

注意📒：

表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换

int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;

2.表达式不能单独存在，其产生的结果必须要被使用

int a = 10;
int b = 20;
a > b? a : b;     // 报错：Error:(15, 14) java: 不是语句

📚7.运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 + 和 -

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);

上述表达式中，由于 + 的优先级要高于 >> , 因此a先和b-a的结果做加法，整体为20，最后再进行右移，因此结果为10

**注意🌴：**运算符之间是有优先级的. 具体的规则不必记忆. 在可能存在歧义的代码中加上括号即可.

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);

🍀逻辑控制

📚1顺序结构

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

📚2分支结构

📖2.1 if 语句

语法格式1

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

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

注意⚠️:

int a=10;
if(a){
    
}//a不是布尔表达式而是整型,故此代码会报错

语法格式2
```
if(布尔表达式){
    // 语句1
}else{
    // 语句2
}
```
如果布尔表达式结果为true，则执行if中语句，否则执行else中语句

3.语法格式3
```
if(布尔表达式1){
    // 语句1
}else if(布尔表达式2){
    // 语句2
}else{
    // 语句3
}
```
表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

【练习】

1.判断一个数字是奇数还是偶数

int num = 10;
if (num % 2 == 0) {
    System.out.println("num 是偶数");
} else {
    System.out.println("num 是奇数");
}

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

int num = 10;
if (num > 0) {
    System.out.println("正数");
} else if (num < 0) {
    System.out.println("负数");
} else {
    System.out.println("0");
}

3.判断一个年份是否为闰年

int year = 2000;
if (year % 100 == 0) {
    // 判定世纪闰年
    if (year % 400 == 0) {
        System.out.println("是闰年");
   } else {
        System.out.println("不是闰年");
   }
} else {
    // 普通闰年
    if (year % 4 == 0) {
        System.out.println("是闰年");
   } else {
        System.out.println("不是闰年");
    }
}

【注意事项】

1.代码风格

// 风格1-----> 推荐
int x = 10;
if (x == 10) {
    // 语句1
} else {
    // 语句2
}
 
// 风格2
int x = 10;
if (x == 10)
{
    // 语句1
}
else
{
    // 语句2
}

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

2.分号问题

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

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

3.悬垂 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 匹配.

但是实际开发中不建议这么写. 最好加上大括号

📖2.2 switch 语句

基本语法

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

执行流程：

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

代码示例: 根据 day 的值输出星期

int day = 1;
switch(day) {
    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("输入有误");
        break;
}

【注意事项】📚

🌳多个case后的常量值不可以重复

🌳switch的括号内只能是以下类型的表达式：

🍃基本类型：byte、char、short、int，注意不能是long, float, double, boolean类型

🍃引用类型：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;
}

📚3.循环结构

📖3.1 while 循环

基本语法格式:

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

循环条件为 true, 则执行循环语句; 否则结束循环

代码示例1: 打印 1 - 10 的数字

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

代码示例2: 计算 1 - 100 的和

int n = 1;
int result = 0;
while (n <= 100) {
    result += n;
 n++;
}
System.out.println(num);
 
// 执行结果
5050

代码示例3: 计算 5 的阶乘

int n = 1;
int result = 1;
while (n <= 5) {
    result *= n;
 n++;
}
System.out.println(num);
 
// 执行结果
120

代码示例4: 计算 1! + 2! + 3! + 4! + 5!

int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
    int factorResult = 1;
    int tmp = 1;
    // 里层循环负责完成求阶乘的细节. 
    while (tmp <= num) {
        factorResult *= tmp;
        tmp++;
   }
    sum += factorResult;
    num++;
}
System.out.println("sum = " + sum);

注意事项 📚:

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

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

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

📖3.2 break

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

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

int num = 100;
while (num <= 200) {
    if (num % 3 == 0) {
        System.out.println("找到了 3 的倍数, 为:" + num);
        break;
   }
    num++;
}
 
// 执行结果
找到了 3 的倍数, 为:102

执行到 break 就会让循环结束.

📖3.3 continue

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

代码示例: 找到 100 - 200 中所有 3 的倍数

int num = 100;
while (num <= 200) {
    if (num % 3 != 0) {
        num++;  // 这里的 ++ 不要忘记! 否则会死循环. 
        continue;
   }
    System.out.println("找到了 3 的倍数, 为:" + num);
    num++;
}

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

📖3.4 for 循环

【基本语法】

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

🌴表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次

🌴表达式2: 循环条件，满则循环继续，否则循环结束

🌴表达式3: 循环变量更新方式

【执行过程】

①②③④—>②③④—>②③④—>②③④—>②③④—>②③④—>…—>②为false，循环结束

【代码示例】

打印 1 - 10 的数字

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

2.计算 1 - 100 的和

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("sum = " + sum);
 
// 执行结果
5050

3.计算 5 的阶乘

int result = 1;
for (int i = 1; i <= 5; i++) {
    result *= i;
}
System.out.println("result = " + result);

计算 1! + 2! + 3! + 4! + 5!
```
int sum = 0;
for (int i = 1; i <= 5; i++) {
    int tmp = 1;
    for (int j = 1; j <= i; j++) {
        tmp *= j;
   }
    sum += tmp;
}
System.out.println("sum = " + sum);
```
【注意事项】 (和while循环类似)
1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
2. 和 if 类似, for 后面的 { 建议和 while 写在同一行.
3. 和 if 类似, for 后面不要多写分号, 否则可能导致循环不能正确执行.
4. 和while循环一样，结束单趟循环用continue，结束整个循环用break

📚4.do while 循环

【基本语法】

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

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

例如：打印 1 - 10

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

【注意事项】

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

📚5.输入输出

📖5.1输出到控制台

基本语法

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

🌴println 输出的内容自带 \n

🌴print 不带 \n printf 的格式化输出方式和 C 语言的 printf 是基本一致的.

代码示例

System.out.println("hello world");
 
int x = 10;
System.out.printf("x = %d\n", x)

格式化字符串

📖5.2 从键盘输入

使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner;  // 需要导入 util 包
 
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
ﬂoat salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法
 
// 执行结果
请输入你的姓名：
张三
请输入你的年龄：
18
请输入你的工资：
1000
你的信息如下：
姓名: 张三
年龄：18
工资：1000.0

Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串：");
String str=sc.nextLine();
String arr=sc.next();
System.out.println("输出结果如下：");
System.out.println(str);
System.out.println(arr);
sc.close();

//执行结果
请输入字符串：
hi computer
hi computer
输出结果如下：
hi computer
hi

//一般推荐使用nextLine(),可读取空格
//而next()不可读取空格

使用 Scanner 循环读取 N 个数字，并求取其平均值

Scanner sc = new Scanner(System.in);
int sum = 0;
int num = 0;
while (sc.hasNextInt()) {
    int tmp = sc.nextInt();
    sum += tmp;
    num++;
}
System.out.println("sum = " + sum);
System.out.println("avg = " + sum / num);
sc.close();
 
// 执行结果
10
40.0
50.5
^Z
sum = 150.5
avg = 30.1

注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl + d).

📚6.猜数字游戏

游戏规则:

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

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

class Test {
    public static void main(String[] args) {
        Random random = new Random(); // 默认随机种子是系统时间
        Scanner sc = new Scanner(System.in);
        int toGuess = random.nextInt(100);
        // System.out.println("toGuess: " + toGuess);
        while (true) {
            System.out.println("请输入要输入的数字: (1-100)");
            int num = sc.nextInt();
            if (num < toGuess) {
                System.out.println("低了");
            } else if (num > toGuess) {
                System.out.println("高了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
        sc.close();
    }
}