当前位置：首页 > news >正文

Java 基础--运算符全解析

news 来源：原创 2025/4/30 7:07:15

【Java 基础】Java 运算符全解析：程序世界的“加减乘除”与“是非对错”

作者：IvanCodes

发布时间：2025年4月29日🐣

专栏：Java教程

嗨，各位 Java 探险家们！👋 掌握了变量、数据类型这些基础“积木”之后 🧱，是时候学习如何让这些积木“动”起来了！这就需要用到 Java 世界的“工具箱”—— 运算符 (Operators)！🛠️

一、算术运算符：数学计算的基础 🧮🔢

这些是最像我们平时数学运算的符号，用来执行基本的算术计算。

+ (加法): 计算两个数的和。也用于字符串连接 🔗。
- (减法): 计算两个数的差。
* (乘法): 计算两个数的积。
/ (除法): 计算两个数的商。注意⚠️：整数除法会舍弃小数部分！
% (取模/求余): 计算两数相除后的余数。常用来判断奇偶性或倍数关系。

代码示例:

public class ArithmeticDemo {public static void main(String[] args) {int a = 10;int b = 3;double c = 10.0;System.out.println("a + b = " + (a + b)); // 加法: 13System.out.println("a - b = " + (a - b)); // 减法: 7System.out.println("a * b = " + (a * b)); // 乘法: 30// 整数除法，舍弃小数System.out.println("a / b (int division) = " + (a / b)); // 除法: 3// 浮点数除法，保留小数System.out.println("c / b (float division) = " + (c / b)); // 除法: 3.333...// 取模 (求余数)System.out.println("a % b = " + (a % b)); // 取模: 1 (10除以3余1)System.out.println("10 % 2 = " + (10 % 2)); // 取模: 0 (偶数)System.out.println("9 % 2 = " + (9 % 2));   // 取模: 1 (奇数)// 字符串连接String firstName = "Ivan";String lastName = "Codes";System.out.println("Full Name: " + firstName + " " + lastName); // 字符串连接}
}

要点📌：特别留意整数除法 / 和取模 % 的行为，它们在编程中非常有用！

二、关系运算符：比较大小与相等 🤔✅❌

关系运算符用于比较两个值之间的关系，其结果总是一个**boolean**类型的值 (true 或 false)。它们是构建条件判断的基础。

== (等于): 判断两个值是否相等。注意⚠️：比较基本类型时比较值，比较引用类型时比较内存地址！
!= (不等于): 判断两个值是否不相等。
> (大于): 判断左边的值是否大于右边的值。
< (小于): 判断左边的值是否小于右边的值。
>= (大于等于): 判断左边的值是否大于或等于右边的值。
<= (小于等于): 判断左边的值是否小于或等于右边的值。

代码示例:

public class RelationalDemo {public static void main(String[] args) {int x = 5;int y = 10;int z = 5;System.out.println("x == y : " + (x == y)); // false <❌>System.out.println("x == z : " + (x == z)); // true <✅>System.out.println("x != y : " + (x != y)); // true <✅>System.out.println("x > y : " + (x > y));   // false <❌>System.out.println("x < y : " + (x < y));   // true <✅>System.out.println("x >= z : " + (x >= z)); // true <✅>System.out.println("y <= z : " + (y <= z)); // false <❌>// 引用类型比较 (通常我们更关心内容是否相等，而不是地址)String s1 = new String("Hello");String s2 = new String("Hello");String s3 = s1;System.out.println("s1 == s2 : " + (s1 == s2)); // false <❌> (比较地址)System.out.println("s1 == s3 : " + (s1 == s3)); // true <✅> (指向同一地址)// 要比较字符串内容是否相等，应使用 equals() 方法System.out.println("s1.equals(s2) : " + s1.equals(s2)); // true <✅> (比较内容)}
}

关键🔑：关系运算的结果是布尔值，直接用于 if, while 等条件语句中！比较引用类型相等性时，优先使用 .equals() 方法（如果该类重写了的话）。

三、逻辑运算符：组合布尔条件的“与或非” 🤝🤷‍♀️🙅‍♂️

逻辑运算符用于组合一个或多个布尔表达式 (true/false)，最终得到一个布尔结果。

&& (逻辑与 / AND): “并且”。当两个操作数都为 true 时，结果才为 true。具有短路特性：如果第一个操作数为 false，则不再计算第二个操作数 <⚡️>。
|| (逻辑或 / OR): “或者”。当 至少一个 操作数为 true 时，结果就为 true。具有短路特性：如果第一个操作数为 true，则不再计算第二个操作数 <⚡️>。
! (逻辑非 / NOT): “取反”。如果操作数为 true，结果为 false；如果操作数为 false，结果为 true。

代码示例:

public class LogicalDemo {public static void main(String[] args) {boolean isSunny = true;boolean isWarm = false;int score = 75;// 逻辑与 &&System.out.println("Is it sunny AND warm? " + (isSunny && isWarm)); // false <👎>System.out.println("Is score > 60 AND score < 80? " + (score > 60 && score < 80)); // true <👍>// 逻辑或 ||System.out.println("Is it sunny OR warm? " + (isSunny || isWarm)); // true <👍>System.out.println("Is score < 0 OR score > 100? " + (score < 0 || score > 100)); // false <👎>// 逻辑非 !System.out.println("Is it NOT sunny? " + (!isSunny)); // false <👎>System.out.println("Is the score NOT valid (outside 0-100)? " + !(score >= 0 && score <= 100)); // false <👎>// 短路效果演示int a = 5;// a > 10 是 false, && 后面的 a++ 不会执行boolean result1 = (a > 10) && (++a > 5);System.out.println("Result1: " + result1 + ", a after &&: " + a); // Result1: false, a after &&: 5 <⚡️>// a < 10 是 true, || 后面的 a++ 不会执行boolean result2 = (a < 10) || (++a > 5);System.out.println("Result2: " + result2 + ", a after ||: " + a); // Result2: true, a after ||: 5 <⚡️>}
}

技巧💡：利用 &&< 和 || 的短路特性可以避免不必要的计算，甚至防止空指针异常！

四、位运算符：深入底层的二进制魔法 🧠💻👾

位运算符直接操作数据的 二进制位 (0 和 1)。它们在某些特定场景下（如图形处理、加密、底层系统编程、性能优化）非常有用，但对于初学者可能不太常用。

& (按位与): 两个操作数的对应位都为 1 时，结果位才为 1 <🔦>。
| (按位或): 两个操作数的对应位至少一个为 1 时，结果位就为 1 <💡>。
^ (按位异或): 两个操作数的对应位不同时，结果位为 1；相同时为 0 <❓>。
~ (按位取反): 将操作数的所有位反转 (0 变 1，1 变 0) <👻>。
<< (左移): 将操作数的所有位向左移动指定的位数，右边空出的位补 0 <⬅️>。相当于乘以 2 的指定次方。
>> (带符号右移): 将操作数的所有位向右移动指定的位数。左边空出的位用原符号位填充 (正数补 0，负数补 1) <➡️>。相当于除以 2 的指定次方。
>>> (无符号右移): 将操作数的所有位向右移动指定的位数。左边空出的位总是补 0 <➡️>。

代码示例 (简单了解):

public class BitwiseDemo {public static void main(String[] args) {int num1 = 5;  // 二进制: 0101int num2 = 3;  // 二进制: 0011// 按位与 &System.out.println("num1 & num2 = " + (num1 & num2)); // 0001 -> 1// 按位或 |System.out.println("num1 | num2 = " + (num1 | num2)); // 0111 -> 7// 按位异或 ^System.out.println("num1 ^ num2 = " + (num1 ^ num2)); // 0110 -> 6// 按位取反 ~ (结果与数的二进制表示和补码有关)System.out.println("~num1 = " + (~num1)); // -6// 左移 << (相当于乘以 2^1)System.out.println("num1 << 1 = " + (num1 << 1)); // 1010 -> 10// 带符号右移 >> (相当于除以 2^1)System.out.println("num1 >> 1 = " + (num1 >> 1)); // 0010 -> 2int negNum = -5; // 负数的二进制表示复杂些 (补码)// 带符号右移 >> (负数右移，左边补 1)System.out.println("negNum >> 1 = " + (negNum >> 1)); // -3// 无符号右移 >>> (负数右移，左边补 0，结果变为很大的正数)System.out.println("negNum >>> 1 = " + (negNum >>> 1)); // 2147483645}
}

提示🔔：位运算对性能敏感的应用很有价值，但日常开发中逻辑运算符更常用。如果对二进制和补码不熟悉，可以先了解一下再深入研究位运算。

五、赋值运算符：给变量“装东西” 📦➡️

赋值运算符用于将右侧的值赋给左侧的变量。

= (简单赋值): 最基本的赋值，将右边的值赋给左边的变量。
复合赋值运算符: 这些是算术运算和赋值的快捷方式。
- += (加后赋值): a += b 等价于 a = a + b <📈>
- -= (减后赋值): a -= b 等价于 a = a - b <📉>
- *= (乘后赋值): a *= b 等价于 a = a * b <✖️=>
- /= (除后赋值): a /= b 等价于 a = a / b <➗=>
- %= (取模后赋值): a %= b 等价于 a = a % b <%= >
- (还有位运算的复合赋值: &=, |=, ^=, <<=, >>=, >>>=)

代码示例:

public class AssignmentDemo {public static void main(String[] args) {int count = 10; // 简单赋值 =int score = 0;// 使用复合赋值运算符score += 50; // score = score + 50; -> score is 50System.out.println("Score after += 50: " + score);count -= 3;  // count = count - 3; -> count is 7System.out.println("Count after -= 3: " + count);count *= 2;  // count = count * 2; -> count is 14System.out.println("Count after *= 2: " + count);// 注意：复合赋值运算符会进行隐式的强制类型转换short num = 5;// num = num + 10; // 编译错误❌: 10 默认是 int，int 不能直接赋给 shortnum += 10; // 编译通过✅: += 会自动将结果转回 short 类型System.out.println("Short num after += 10: " + num); // 15}
}

优点👍：复合赋值运算符不仅简洁，有时还能提高性能（虽然现代编译器优化得很好），并且处理了隐式类型转换。

六、三元运算符：简洁的 if-else 选择 🤔❓✅❌

三元运算符（也叫条件运算符）是 Java 中唯一需要三个操作数的运算符。它是 if-else 语句的一种简洁形式，特别适合用于简单的条件赋值。

语法： 条件表达式 ? 表达式1 : 表达式2
执行逻辑：
1. 计算 条件表达式 (必须是布尔值)。
2. 如果条件为 true，则整个表达式的结果是 表达式1 的值 <✅>。
3. 如果条件为 false，则整个表达式的结果是 表达式2 的值 <❌>。

代码示例:

public class TernaryDemo {public static void main(String[] args) {int score = 85;String result;// 使用 if-elseif (score >= 60) {result = "Pass <✅>";} else {result = "Fail <❌>";}System.out.println("Result (if-else): " + result);// 使用三元运算符实现相同逻辑result = (score >= 60) ? "Pass <✅>" : "Fail <❌>"; // <❓> :System.out.println("Result (ternary): " + result);// 也可以用于直接返回值或更复杂的表达式int age = 17;String access = (age >= 18) ? "Granted" : "Denied";System.out.println("Access Status: " + access); // Deniedint max = (score > 90) ? 100 : score; // 如果分数>90则取100, 否则取原分数System.out.println("Adjusted Max Score: " + max); // 85}
}

适用场景🎯：当 if-else 逻辑非常简单，主要是根据条件给变量赋不同的值时，使用三元运算符可以使代码更紧凑。但不要滥用，如果逻辑过于复杂，嵌套的三元运算符会降低可读性！

七、总结 ✨✅

今天我们学习了 Java 中最常用的一些运算符：

算术运算符 🧮：进行数学计算。
关系运算符 🤔：进行比较，返回布尔值。
逻辑运算符 🤝：组合布尔条件，注意短路。
位运算符 🧠：操作二进制位（了解即可，按需深入）。
赋值运算符 📦：给变量赋值，复合赋值很方便。
三元运算符 ❓：简洁的条件赋值。

熟练掌握这些运算符是编写任何有意义程序的基础。多练习，你就能像指挥官一样，让数据按照你的意愿进行各种运算和判断！ 👨‍💻👩‍💻

八、练练手，检验成果！✏️🧠

掌握了工具，就来试试看吧！

⭐ 基础计算 ⭐

计算 (15 + 5) * 2 / 4 % 3 的结果是多少？写出计算步骤。
声明两个 int 变量 a = 10, b = 20。写代码交换它们的值（不允许使用第三个变量，可以考虑使用算术或位运算符）。

⭐ 逻辑判断 ⭐

给定一个年份 year，写一个布尔表达式判断它是否是闰年。闰年条件：能被 4 整除但不能被 100 整除，或者能被 400 整除。
解释 || 和 | 作为逻辑运算符时的主要区别，尤其是在效率方面。

⭐ 综合运用 ⭐

使用三元运算符，根据一个整数 num 的值，打印输出 “Positive”, “Negative”, 或 “Zero”。

九、参考答案 ✅💡

⭐ 基础计算答案 ⭐

1.计算结果与步骤:

15 + 5 -> 20
20 * 2 -> 40
40 / 4 -> 10 (整数除法)
10 % 3 -> 1 (10 除以 3 余 1)
最终结果：1

2.交换变量值 (不使用第三个变量):

方法一：使用算术运算

int a = 10;
int b = 20;
System.out.println("Before: a=" + a + ", b=" + b);
a = a + b; // a = 30
b = a - b; // b = 30 - 20 = 10
a = a - b; // a = 30 - 10 = 20
System.out.println("After (Arithmetic): a=" + a + ", b=" + b);

方法二：使用位运算 (异或) (效率更高)

int a = 10; // 1010
int b = 20; // 10100 (为了对齐写成 01010 和 10100)
System.out.println("Before: a=" + a + ", b=" + b);
a = a ^ b; // a = 10 ^ 20 = (01010 ^ 10100) = 11110 (30)
b = a ^ b; // b = 30 ^ 20 = (11110 ^ 10100) = 01010 (10)
a = a ^ b; // a = 30 ^ 10 = (11110 ^ 01010) = 10100 (20)
System.out.println("After (Bitwise XOR): a=" + a + ", b=" + b);

⭐ 逻辑判断答案 ⭐

3.判断闰年表达式:

int year = 2024; // 示例年份
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + " is leap year? " + isLeapYear); // true

4.|| (逻辑或) vs | (按位或，也可作逻辑或):

主要区别 (作为逻辑运算符时): || 具有短路效果。如果第一个操作数为 true，它就不会计算第二个操作数，直接返回 true。而 | 总会计算两边的操作数，即使第一个已经是 true。
效率方面: 因为 || 可能避免计算第二个操作数，所以在逻辑运算中通常 效率更高 <⚡️>。因此，进行逻辑判断时强烈推荐使用 || 和 &&。| 和 & 主要用于位运算。

⭐ 综合运用答案 ⭐

5.使用三元运算符判断正负零:

int num = -5; // 示例数字
String sign = (num > 0) ? "Positive <+>" : ((num < 0) ? "Negative <->" : "Zero <0>");
System.out.println("The number " + num + " is: " + sign); // The number -5 is: Negative <->num = 0;
sign = (num > 0) ? "Positive <+>" : ((num < 0) ? "Negative <->" : "Zero <0>");
System.out.println("The number " + num + " is: " + sign); // The number 0 is: Zero <0>num = 10;
sign = (num > 0) ? "Positive <+>" : ((num < 0) ? "Negative <->" : "Zero <0>");
System.out.println("The number " + num + " is: " + sign); // The number 10 is: Positive <+>