第三课：运算和逻辑
（一）运算符
Java 提供了一系列运算符来进行数学计算、逻辑判断和位操作等，主要分为以下几类：
| 运算符类别 | 作用 |
|---|---|
| 算术运算符 | 进行基本数学计算（+, -, *, /, %, ++, --） |
| 关系运算符 | 比较两个值的关系（==, !=, >, <, >=, <=） |
| 位运算符 | 操作二进制位（&, ` |
| 逻辑运算符 | 逻辑判断（&&, ` |
| 赋值运算符 | 赋值及复合运算（=, +=, -=, *=, /=, %=） |
| 条件（三元）运算符 | 根据条件返回不同的值（condition ? true_value : false_value） |
instanceof 运算符 | 检查对象是否属于某个类 |
| 运算符优先级 | 决定运算符执行的先后顺序 |
1. 算术运算符
用于数学运算，支持整数和浮点数计算。
| 运算符 | 描述 | 示例（假设 a = 10, b = 20） | 结果 |
|---|---|---|---|
+ | 加法 | a + b | 30 |
- | 减法 | a - b | -10 |
* | 乘法 | a * b | 200 |
/ | 除法 | b / a | 2 |
% | 取余 | b % a | 0 |
++ | 自增 | a++ 或 ++a | 11 |
-- | 自减 | b-- 或 --b | 19 |
示例
public class ArithmeticOperators {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("b / a = " + (b / a));
System.out.println("b % a = " + (b % a));
}
}
Java 中没有直接内置 次方运算符
但可以使用
Math.pow()方法 进行幂运算（次方计算）
double result = Math.pow(2, 3); // 计算 2^3
System.out.println(result); // 输出 8.0
// 如果需要整数，可以使用 int
int intResult = (int) Math.pow(2, 3); // 强制转换为整数
System.out.println(intResult); // 输出 8
2. 关系运算符
用于比较两个值，结果为 true 或 false。
| 运算符 | 描述 | 示例（a = 10, b = 20） | 结果 |
|---|---|---|---|
== | 相等 | a == b | false |
!= | 不等 | a != b | true |
> | 大于 | a > b | false |
< | 小于 | a < b | true |
>= | 大于等于 | a >= b | false |
<= | 小于等于 | a <= b | true |
3. 位运算符
操作二进制位，适用于整数类型（int, long, short, byte, char）。
| 运算符 | 描述 | 示例（a = 60（0011 1100）, b = 13（0000 1101）） | 结果 |
|---|---|---|---|
& | 按位与 | a & b | 0000 1100（12） |
| ` | ` | 按位或 | `a |
^ | 按位异或 | a ^ b | 0011 0001（49） |
~ | 按位取反 | ~a | 1100 0011（-61） |
<< | 左移 | a << 2 | 1111 0000（240） |
>> | 右移 | a >> 2 | 0000 1111（15） |
>>> | 无符号右移 | a >>> 2 | 0000 1111（15） |
4. 逻辑运算符
用于布尔逻辑判断，返回 true 或 false。
| 运算符 | 描述 | 示例（a = true, b = false） | 结果 |
|---|---|---|---|
&& | 逻辑与 | a && b | false |
| ` | ` | 逻辑或 | |
! | 逻辑非 | !a | false |
5. 赋值运算符
用于给变量赋值。
| 运算符 | 示例（c = 10） | 等效于 |
|---|---|---|
= | c = a + b | c = a + b |
+= | c += a | c = c + a |
-= | c -= a | c = c - a |
*= | c *= a | c = c * a |
/= | c /= a | c = c / a |
%= | c %= a | c = c % a |
&= | c &= a | c = c & a |
^= | c ^= a | c = c ^ a |
| ` | =` | `c |
6. 条件（三元）运算符
格式：
变量 = (条件) ? 表达式1 : 表达式2;
示例
int age = 18;
String result = (age >= 18) ? "成年人" : "未成年人";
System.out.println(result); // 输出：成年人
7. instanceof 运算符
- 检查对象是否是某个类的实例
String name = "James";
boolean result = name instanceof String; // true
8. 运算符优先级
当多个运算符出现在一个表达式中，优先级决定了运算顺序。
| 类别 | 运算符 | 方向 |
|---|---|---|
| 后缀 | () [] . | 左到右 |
| 一元 | ++ -- + - ~ ! | 右到左 |
| 乘性 | * / % | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | > >= < <= instanceof | 左到右 |
| 相等 | == != | 左到右 |
| 按位 | `& ^ | ` |
| 逻辑 | `&& | |
| 条件 | ?: | 右到左 |
| 赋值 | = += -= *= /= | 右到左 |
(二) 循环结构
Java 提供了 while、do...while 和 for 这三种主要的循环控制结构，
以及 break 和 continue 关键字用于控制循环流程。
1. while 循环
while 是最基本的循环结构，只要条件为 true，循环体就会一直执行。
语法格式：
while (条件表达式) {
// 循环体
}
示例：（输出10-14）
public class WhileLoopExample {
public static void main(String[] args) {
int x = 10;
while (x < 15) {
System.out.println("当前 x 值: " + x);
x++; // 递增
}
}
}
2. do...while 循环（不常用）
do...while 和 while 类似，但 do...while 至少会执行一次，因为循环体在条件检查之前执行。
语法格式：
do {
// 代码块
} while (条件表达式);
示例：（输出10-14）
public class DoWhileExample {
public static void main(String[] args) {
int x = 10;
do {
System.out.println("当前 x 值: " + x);
x++;
} while (x < 15);
}
}
3. for 循环
for 循环 是最常见的循环结构，适用于 已知循环次数 的情况。 语法格式：
for (初始化; 布尔表达式; 更新) {
// 循环体
}
示例：（输出10-14）
public class ForLoopExample {
public static void main(String[] args) {
for (int x = 10; x < 15; x++) {
System.out.println("当前 x 值: " + x);
}
}
}
注意 for 循环里的变量 x 前面不要忘记加上 int
4. 增强型 for 循环
增强型 for（for-each）专门用于遍历数组和集合。
语法格式：
for (数据类型 变量名 : 数组/集合) {
// 代码
}
示例（遍历数组）：
public class EnhancedForExample {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
for (int num : numbers) {
System.out.println("数组元素：" + num);
}
}
}
运行结果：
数组元素：10
数组元素：20
数组元素：30
数组元素：40
数组元素：50
❌ 不能修改数组元素的值（要修改仍需
for）。
5. break 关键字
break 立即跳出整个循环，适用于 提前终止循环 的情况。
示例：
public class BreakExample {
public static void main(String[] args) {
for (int x = 1; x <= 5; x++) {
if (x == 3) {
System.out.println("x == 3，跳出循环");
break; // 立即终止循环
}
System.out.println("当前 x 值: " + x);
}
}
}
运行结果：
当前 x 值: 1
当前 x 值: 2
x == 3，跳出循环
6. continue 关键字
continue 立即跳过当前循环的剩余部分，进入下一次循环。
示例：
public class ContinueExample {
public static void main(String[] args) {
for (int x = 1; x <= 5; x++) {
if (x == 3) {
System.out.println("x == 3，跳过");
continue; // 直接进入下一次循环
}
System.out.println("当前 x 值: " + x);
}
}
}
运行结果：
当前 x 值: 1
当前 x 值: 2
x == 3，跳过
当前 x 值: 4
当前 x 值: 5
7. 嵌套循环
循环中包含另一个循环称为嵌套循环，常用于 遍历二维数组、打印模式等。
示例：打印 5×5 星号
public class NestedLoopExample {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}
运行结果：
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
(三) 条件结构
1. if 语句
语法
if (布尔表达式) {
// 如果布尔表达式为 true，执行这段代码
}
示例
public class IfExample {
public static void main(String[] args) {
int x = 10;
if (x < 20) {
System.out.println("x 小于 20");
}
}
}
2. if...else 语句
当 if 语句的条件 不满足（false） 时，执行 else 代码块。
语法
if (布尔表达式) {
// 如果布尔表达式为 true，执行
} else {
// 如果布尔表达式为 false，执行
}
示例
public class IfElseExample {
public static void main(String[] args) {
int x = 30;
if (x < 20) {
System.out.println("x 小于 20");
} else {
System.out.println("x 大于或等于 20");
}
}
}
3. if...else if...else 语句
适用于多个条件判断，当 if 条件不满足时，会依次检查 else if 语句。
语法
if (布尔表达式1) {
// 如果布尔表达式1 为 true，执行
} else if (布尔表达式2) {
// 如果布尔表达式2 为 true，执行
} else if (布尔表达式3) {
// 如果布尔表达式3 为 true，执行
} else {
// 如果上面条件都不满足，执行
}
示例
public class IfElseIfExample {
public static void main(String[] args) {
int x = 30;
if (x == 10) {
System.out.println("x 等于 10");
} else if (x == 20) {
System.out.println("x 等于 20");
} else if (x == 30) {
System.out.println("x 等于 30");
} else {
System.out.println("x 不是 10、20 或 30");
}
}
}
4. 嵌套 if...else 语句
可以在 if 或 else 代码块内 再次嵌套 if 语句。
语法
if (条件1) {
if (条件2) {
// 如果条件1 和 条件2 均满足，执行
}
}
示例
public class NestedIfExample {
public static void main(String[] args) {
int x = 30;
int y = 10;
if (x == 30) {
if (y == 10) {
System.out.println("x = 30, y = 10");
}
}
}
}
(四) Switch Case 语句
switch case 语句用于 判断变量 是否与 多个可能值 相等，每个值称为一个 分支（case）。
语法
switch(expression) {
case value1:
// 执行语句
break; // 可选
case value2:
// 执行语句
break; // 可选
...
default: // 可选
// 当所有 case 都不匹配时执行
}
注意：
case语句后跟要比较的 常量值，不能是变量或表达式。如果没有 break 语句，后续 case 代码依然会继续执行，而且直接忽略了后续 case 的判断条件
switch case 适用数据类型
| 数据类型 | 支持 switch | 说明 |
|---|---|---|
int | ✅ 支持 | 常见数值匹配 |
char | ✅ 支持 | 单个字符匹配 |
short | ✅ 支持 | |
byte | ✅ 支持 | |
String | ✅ Java 7+ | Java 7 及以上支持字符串匹配 |
long | ❌ 不支持 | 需要转换为 int |
float/double | ❌ 不支持 | 由于浮点数精度问题，不适用于 switch |
示例一
public class SwitchWithoutBreak {
public static void main(String[] args) {
int i = 1;
switch (i) {
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
default:
System.out.println("default");
}
}
}
运行结果
1
2
default
思考：明明 i ≠2， 为什么会输出 2 ？
switch语句在找到匹配的case后，如果没有break，则会顺序执行后面的所有case代码，而不再进行匹配。直到遇到break或者到达default
示例二
public class SwitchExample {
public static void main(String[] args) {
char grade = 'C';
switch (grade) {
case 'A':
System.out.println("优秀");
break;
case 'B':
case 'C': // case 语句可以合并
System.out.println("良好");
break;
case 'D':
System.out.println("及格");
break;
case 'F':
System.out.println("需要努力");
break;
default:
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}
运行结果
良好
你的等级是 C
switch case 与 if-else 对比
switch case | if-else | |
|---|---|---|
| 适用情况 | 适用于离散值（int、char、String） | 适用于范围判断（<、>、<=、>=） |
| 代码结构 | 清晰简洁，但仅适用于相等比较 | 适用于复杂逻辑，但代码较长 |
| 可读性 | 更清晰 | 可能嵌套较深 |
| 性能 | 编译后更高效（使用跳转表） | 逐个判断，可能较慢 |