Java 运算符

学习目标

掌握 Java 中 8 类核心运算符的使用方法
理解各类运算符的优先级与结合性
避免常见运算符使用误区
能够在实际编码中灵活运用复合赋值、三元运算等技巧

1. 算术运算符

详情请参考《Java 算数运算符》

用于对基本数据类型（如 int、double）执行加、减、乘、除、取模等数学运算。

public class Main {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        int sum = a + b;      // 加法
        int diff = a - b;     // 减法
        int mul = a * b;      // 乘法
        int div = a / b;      // 整数除法（结果为 3）
        int mod = a % b;      // 取模（余数为 1）

        System.out.println("Sum: " + sum);           // 13
        System.out.println("Difference: " + diff);   // 7
        System.out.println("Multiplication: " + mul); // 30
        System.out.println("Division: " + div);      // 3
        System.out.println("Modulus: " + mod);       // 1
    }
}

注意：整数除法会截断小数部分（如 10 / 3 = 3），若需保留小数，请使用浮点类型（如 double）。

2. 一元运算符

详情请参考《Java 一元运算符》

仅作用于一个操作数，常用于自增、自减或取反。

class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;

        System.out.println("Postincrement : " + (a++)); // 先用后加 → 10
        System.out.println("Preincrement : " + (++a));  // 先加后用 → 12

        System.out.println("Postdecrement : " + (b--)); // 先用后减 → 10
        System.out.println("Predecrement : " + (--b));  // 先减后用 → 8
    }
}

运算符	含义	示例
`++x`	前置自增	先加 1 再使用
`x++`	后置自增	先使用再加 1
`--x`	前置自减	先减 1 再使用
`x--`	后置自减	先使用再减 1
`-x`	取负	`-5` → `-5`
`!x`	逻辑非（布尔）	`!true` → `false`

3. 赋值运算符

详情请参考《Java 赋值运算符》

将右侧的值赋给左侧变量。支持复合赋值以简化代码。

public class Main {
    public static void main(String[] args) {
        int n = 10;
        
        n += 5;  // 等价于 n = n + 5 → 15
        n *= 2;  // → 30
        n -= 5;  // → 25
        n /= 2;  // → 12（整数除法）
        n %= 3;  // → 0

        System.out.println("After += : " + n); // 依次输出各步骤结果
    }
}

常用复合赋值运算符：

+=, -=, *=, /=, %=
优势：代码更简洁，可读性更强

4. 关系运算符

详情请参考《Java 关系运算符》

用于比较两个值，返回 boolean 类型结果（true 或 false），常用于 if 和循环条件中。

int a = 10, b = 3, c = 5;

System.out.println("a > b: " + (a > b));   // true
System.out.println("a < b: " + (a < b));   // false
System.out.println("a >= b: " + (a >= b)); // true
System.out.println("a <= b: " + (a <= b)); // false
System.out.println("a == c: " + (a == c)); // false
System.out.println("a != c: " + (a != c)); // true

注意：== 比较的是值（基本类型）或引用地址（对象），不是内容！

5. 逻辑运算符

详情请参考《Java 逻辑运算符》

用于组合多个布尔表达式，具有短路特性（short-circuiting）：

&&：逻辑与（AND）— 若左操作数为 false，则不计算右操作数
||：逻辑或（OR）— 若左操作数为 true，则不计算右操作数
!：逻辑非（NOT）

boolean x = true, y = false;

System.out.println("x && y: " + (x && y)); // false
System.out.println("x || y: " + (x || y)); // true
System.out.println("!x: " + (!x));         // false

短路示例：if (obj != null && obj.isValid()) — 若 obj 为 null，则不会调用 isValid()，避免空指针异常。

6. 三元运算符

详情请参考《Java 三元运算符》

if-else 的简写形式，格式为：
条件 ? 表达式1 : 表达式2

int a = 20, b = 10, c = 30;
int result = (a > b) ? (a > c ? a : c) : (b > c ? b : c);
System.out.println("Max of three numbers = " + result); // 30

适用场景：简单条件赋值，避免冗长的 if-else。

7. 位运算符

详情请参考《Java 位运算符》

直接对二进制位进行操作，适用于底层优化或特定算法。

位逻辑运算

&：按位与
|：按位或
^：按位异或
~：按位取反

位移运算

<<：左移（相当于 ×2ⁿ）
>>：带符号右移（高位补符号位）
>>>：无符号右移（高位补 0）

int d = 0b1010; // 10
int e = 0b1100; // 12

System.out.println("d & e : " + (d & e)); // 8  (1000)
System.out.println("d | e : " + (d | e)); // 14 (1110)
System.out.println("d ^ e : " + (d ^ e)); // 6  (0110)
System.out.println("~d : " + (~d));       // -11（补码表示）
System.out.println("d << 2 : " + (d << 2)); // 40 (101000)
System.out.println("e >> 1 : " + (e >> 1)); // 6  (0110)
System.out.println("e >>> 1 : " + (e >>> 1)); // 6（正数时与 >> 相同）

提示：负数的 >> 和 >>> 结果不同，因符号位处理方式不同。

8. instanceof 运算符

详情请参考《Java instanceof 运算符》

用于运行时类型检查，判断对象是否是指定类、子类或接口的实例。

String str = "Hello";
System.out.println(str instanceof String); // true

Object obj = new Integer(10);
System.out.println(obj instanceof Integer); // true
System.out.println(obj instanceof String);  // false

用途：在向下转型（downcasting）前做安全检查，避免 ClassCastException。

常见错误

混淆 = 与 ==
- = 是赋值，== 是比较。
- 错误示例：if (x = 5) → 编译错误（应为 ==）
浮点数直接用 == 比较
- 由于精度问题，0.1 + 0.2 == 0.3 返回 false！
- 正确做法：使用误差范围比较，如 Math.abs(a - b) < 1e-9
忽略整数除法截断
- 7 / 2 = 3，而非 3.5
- 解决方案：至少一方转为 double，如 (double)7 / 2
循环中频繁使用 + 拼接字符串
- 每次 + 都创建新 String 对象，效率低下
- 推荐：使用 StringBuilder 进行批量拼接

重点总结

运算符类别	核心作用	典型代表
算术	数学计算	`+`, `-`, `*`, `/`, `%`
一元	单操作数操作	`++`, `--`, `!`
赋值	变量赋值	`=`, `+=`, `-=`
关系	比较大小 / 相等	`>`, `<`, `==`, `!=`
逻辑	布尔组合（支持短路）	`&&`, `
三元	条件赋值	`? :`
位运算	二进制位操作	`&`, `
instanceof	运行时类型判断	`obj instanceof Type`

思考题

为什么 10 / 3 的结果是 3 而不是 3.333...？如何修改代码使其输出浮点结果？
在什么场景下必须使用 instanceof？能否举例说明其在多态中的作用？
分析以下代码的输出，并解释原因：
```
int x = 5;
System.out.println(x++ + ++x);
```