Java 基本运算符

Java 基本运算符

运算符是特殊的符号，对一个、两个或三个操作数（变量或值）执行操作并返回结果。Java 提供了一组丰富的运算符，分组如下：

• 算术运算符 (Arithmetic Operators)
• 关系运算符 (Relational Operators)
• 位运算符 (Bitwise Operators)
• 逻辑运算符 (Logical Operators)
• 赋值运算符 (Assignment Operators)
• 其他运算符 (Miscellaneous Operators) (三元运算符 Ternary, instanceof)

算术运算符

用于数学计算。

假设 int a = 10; 且 int b = 20;

运算符 (Operator)	描述 (Description)	示例 (Example)
+	加法 (Addition)	a + b 结果为 30
-	减法 (Subtraction)	a - b 结果为 -10
*	乘法 (Multiplication)	a * b 结果为 200
/	除法 (Division) (如果两个操作数都是整数，则为整数除法)	b / a 结果为 2。10 / 3 结果为 3。
%	取模 (Modulus) (除法的余数)	b % a 结果为 0。10 % 3 结果为 1。
++	自增 (Increment) (前缀 ++a 或后缀 a++)。将值增加 1。	a = 10; b = ++a; (a 为 11, b 为 11)。a = 10; b = a++; (a 为 11, b 为 10)。
--	自减 (Decrement) (前缀 --a 或后缀 a--)。将值减少 1。	a = 10; b = --a; (a 为 9, b 为 9)。a = 10; b = a--; (a 为 9, b 为 10)。

关系运算符

用于比较两个值。结果始终是 boolean 类型（true 或 false）。

假设 int a = 10; 且 int b = 20;

运算符 (Operator)	描述 (Description)	示例 (Example)
==	等于 (Equal to)	(a == b) 结果为 false。
!=	不等于 (Not equal to)	(a != b) 结果为 true。
>	大于 (Greater than)	(a > b) 结果为 false。
<	小于 (Less than)	(a < b) 结果为 true。
>=	大于或等于 (Greater than or equal to)	(a >= b) 结果为 false。
<=	小于或等于 (Less than or equal to)	(a <= b) 结果为 true。

位运算符

直接操作整型（long、int、short、char、byte）的单个位。

假设 int a = 60; (二进制 0011 1100) 且 int b = 13; (二进制 0000 1101)

运算符 (Operator)	描述 (Description)	示例 (Example)
&	按位与 (Bitwise AND) (如果两个位都是 1，则结果为 1)	(a & b) 结果为 12 (二进制 0000 1100)
|	按位或 (Bitwise OR) (如果至少一个位是 1，则结果为 1)	(a | b) 结果为 61 (二进制 0011 1101)
^	按位异或 (Bitwise XOR) (如果位不同，则结果为 1)	(a ^ b) 结果为 49 (二进制 0011 0001)
~	按位取反 (Bitwise Complement) (一元 - 翻转所有位)	(~a) 结果为 -61 (由于使用二进制补码表示)
<<	带符号左移 (Signed Left Shift) (将位左移，用 0 填充)	a << 2 结果为 240 (二进制 1111 0000)
>>	带符号右移 (Signed Right Shift) (将位右移，用符号位填充)	a >> 2 结果为 15 (二进制 0000 1111)。(-60) >> 2 会用 1 填充。
>>>	无符号右移 (Unsigned Right Shift) (将位右移，用 0 填充)	a >>> 2 结果为 15 (二进制 0000 1111)。(-60) >>> 2 用 0 填充，结果为一个很大的正数。

逻辑运算符

操作 boolean 类型操作数。常与关系运算符一起使用创建复杂条件。

假设 boolean x = true; 且 boolean y = false;

运算符 (Operator)	描述 (Description)	示例 (Example)
&&	逻辑与 (Logical AND) (如果两个操作数都为 true，则为 true)。短路：如果左操作数为 false，则不评估右操作数。	(x && y) 结果为 false。
||	逻辑或 (Logical OR) (如果至少一个操作数为 true，则为 true)。短路：如果左操作数为 true，则不评估右操作数。	(x || y) 结果为 true。
!	逻辑非 (Logical NOT) (一元 - 反转布尔值)	!x 结果为 false。!y 结果为 true。

注意：Java 也支持按位 & 和 | 运算符用于 boolean 操作数，但它们是不短路的（两边总是会被评估）。除非您特别需要非短路行为，否则逻辑操作请使用 && 和 ||。

赋值运算符

用于将值赋给变量。

运算符 (Operator)	描述 (Description)	示例 (假设 int c = 10, a = 5) (Example (Assume int c = 10, a = 5))
=	简单赋值 (Simple Assignment)	c = a; (c 变为 5)
+=	加法赋值 (Add and Assign)	c += a; 等同于 c = c + a; (c 变为 15)
-=	减法赋值 (Subtract and Assign)	c -= a; 等同于 c = c - a; (c 变为 5)
*=	乘法赋值 (Multiply and Assign)	c *= a; 等同于 c = c * a; (c 变为 50)
/=	除法赋值 (Divide and Assign)	c /= a; 等同于 c = c / a; (c 变为 2)
%=	取模赋值 (Modulus and Assign)	c %= a; 等同于 c = c % a; (c 变为 0)
<<=	左移赋值 (Left Shift and Assign)	c <<= 2; 等同于 c = c << 2;
>>=	带符号右移赋值 (Signed Right Shift and Assign)	c >>= 2; 等同于 c = c >> 2;
>>>=	无符号右移赋值 (Unsigned Right Shift and Assign)	c >>>= 2; 等同于 c = c >>> 2;
&=	按位与赋值 (Bitwise AND and Assign)	c &= a; 等同于 c = c & a;
|=	按位或赋值 (Bitwise OR and Assign)	c |= a; 等同于 c = c | a;
^=	按位异或赋值 (Bitwise XOR and Assign)	c ^= a; 等同于 c = c ^ a;

其他运算符

条件运算符 (三元运算符 ? :)

是 if-else 语句的简写形式，常用于简单的赋值。语法：条件 ? value_if_true : value_if_false

示例：

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

        // 如果 (a == 1) 为 true，将 20 赋给 b，否则将 30 赋给 b
        b = (a == 1) ? 20 : 30;
        System.out.println("Value of b is: " + b); // 输出: 30

        // 如果 (a == 10) 为 true，将 20 赋给 b，否则将 30 赋给 b
        b = (a == 10) ? 20 : 30;
        System.out.println("Value of b is: " + b); // 输出: 20

        String status = (a > 5) ? "Active" : "Inactive";
        System.out.println("Status: " + status); // 输出: Active
    }
}

instanceof 运算符

检查对象是否是特定类、子类或接口实现的实例。返回 boolean 值。

语法：(对象引用 instanceof 类型)

示例：

public class InstanceofTest {
    public static void main(String[] args) {
        String name = "James";
        boolean isString = name instanceof String; // true
        System.out.println("Is name a String? " + isString); // name 是 String 吗？

        Object obj = name; // 将 String 赋给 Object 引用
        boolean isObject = obj instanceof Object; // true
        System.out.println("Is obj an Object? " + isObject); // obj 是 Object 吗？

        boolean isList = name instanceof java.util.List; // false
        System.out.println("Is name a List? " + isList); // name 是 List 吗？

        // 检查 null
        String nullStr = null;
        boolean isNullString = nullStr instanceof String; // false (instanceof 对 null 操作数返回 false)
        System.out.println("Is nullStr a String? " + isNullString); // nullStr 是 String 吗？

        // 继承检查
        Vehicle myVehicle = new Car();
        boolean isVehicle = myVehicle instanceof Vehicle; // true
        boolean isCar = myVehicle instanceof Car;       // true
        System.out.println("Is myVehicle a Vehicle? " + isVehicle); // myVehicle 是 Vehicle 吗？
        System.out.println("Is myVehicle a Car? " + isCar); // myVehicle 是 Car 吗？

        // instanceof 的模式匹配 (Java 16+)
        Object data = "Some Text";
        if (data instanceof String s) {
            // 如果为 true，自动将 'data' 转换为 String 's'
            System.out.println("String length: " + s.length()); // 字符串长度：
        } else {
            System.out.println("Not a String"); // 不是 String
        }
    }
}

class Vehicle {}
class Car extends Vehicle {}

运算符优先级

决定了表达式中运算符的评估顺序。优先级高的运算符先评估。如果运算符优先级相同，则根据结合性（通常从左到右）进行评估。

示例：x = 7 + 3 * 2; 乘法 (*) 优先级高于加法 (+)，因此先评估 3 * 2（结果为 6），然后评估 7 + 6（结果为 13）。x 变为 13。

使用括号 () 来覆盖优先级并强制特定的评估顺序。示例：x = (7 + 3) * 2; (评估结果为 20)。

优先级表 (从高到低):

类别 (Category)	运算符 (Operator)	结合性 (Associativity)
后缀 (Postfix)	expr++ expr-- [] . ()(方法调用)	从左到右 (Left to right)
一元 (Unary)	++expr --expr +expr -expr ~ !	从右到左 (Right to left)
乘法 (Multiplicative)	* / %	从左到右 (Left to right)
加法 (Additive)	+ -	从左到右 (Left to right)
移位 (Shift)	<< >> >>>	从左到右 (Left to right)
关系 (Relational)	< > <= >= instanceof	从左到右 (Left to right)
相等 (Equality)	== !=	从左到右 (Left to right)
按位与 (Bitwise AND)	&	从左到右 (Left to right)
按位异或 (Bitwise XOR)	^	从左到右 (Left to right)
按位或 (Bitwise OR)	|	从左到右 (Left to right)
逻辑与 (Logical AND)	&&	从左到右 (Left to right)
逻辑或 (Logical OR)	||	从左到右 (Left to right)
条件 (三元) (Conditional (Ternary))	? :	从右到左 (Right to left)
赋值 (Assignment)	= += -= *= /= %= &= ^= |= <<= >>= >>>=	从右到左 (Right to left)

接下来学什么？

下一章探讨 Java 中的循环控制结构（for、while、do-while），这些是重复执行代码块的重要工具。