1. 算术运算符
常见的算术运算符
+（加法）-（减法）*（乘法）/（除法）%（取模/取余）
/ 运算符注意事项
- 整数除法：如果两个整数进行除法运算，结果会自动舍弃小数部分，返回整数。
原因：运算结果的类型由操作数的最高类型决定，整数相除时最高类型为int a = 10; int b = 3; System.out.println(a / b); // 输出：3（而非 3.333...）int。
+ 运算符的额外功能
- 字符串连接符：
当+运算符与字符串结合使用时，会将其余操作数转为字符串并拼接。System.out.println("结果是：" + 5 + 3); // 输出：结果是：53（非 8） - 运算优先级规则：
- 能算则算：若操作数均为数值类型，则进行数学运算。
- 不能算则拼接：若存在字符串，则转为字符串拼接。
System.out.println(5 + 3 + "结果"); // 输出：8结果（先计算 5+3，再拼接） System.out.println("结果" + 5 + 3); // 输出：结果53（直接拼接）
2. 自增、自减运算符
运算符定义及作用
- 运算符：
++（自增）、--（自减） - 功能：对变量的值进行
+1或-1操作。 - 限制：只能操作变量，不能直接操作字面量。
int a = 5; a++; // 合法操作 // 5++; // 报错，不能操作字面量
运算符前置与后置的区别
-
单独使用：
前置（++a）和后置（a++）无区别，均直接修改变量值。int x = 10; x++; // x 变为 11 ++x; // x 变为 12 -
非单独使用（参与运算或赋值）：
- 前置：先自增/自减，再使用变量。
int a = 5; int b = ++a; // a 先自增为 6，再赋值给 b（b=6） - 后置：先使用变量原值，再自增/自减。
int a = 5; int b = a++; // 先将 a=5 赋值给 b（b=5），再自增为 6
- 前置：先自增/自减，再使用变量。
注意事项
- 逻辑陷阱：避免在复杂表达式中混合使用前置和后置，可能导致逻辑混乱。
int i = 1; int j = i++ + ++i; // 实际结果为：1 + 3 = 4 - 代码可读性：优先使用清晰写法，减少隐晦的自增/自减操作。
总结
- 自增/自减是高效修改变量的工具，但需注意前置与后置的逻辑差异。
- 在复杂表达式中慎用，确保代码逻辑清晰易懂。
3. 赋值运算符
基本赋值运算符
- 符号：
= - 功能：将右侧的值赋给左侧的变量（从右向左执行）。
int a = 10; // 将右侧的 10 赋值给左侧的变量 a
扩展赋值运算符
扩展赋值运算符结合算术运算与赋值操作，简化代码。
| 符号 | 用法 | 作用 | 底层代码形式 |
|---|---|---|---|
+= | a += b | 加后赋值 | a = (a的类型)(a + b); |
-= | a -= b | 减后赋值 | a = (a的类型)(a - b); |
*= | a *= b | 乘后赋值 | a = (a的类型)(a * b); |
/= | a /= b | 除后赋值 | a = (a的类型)(a / b); |
%= | a %= b | 取余后赋值 | a = (a的类型)(a % b); |
底层逻辑说明：
- 扩展赋值运算符会先将运算结果强制转换为左侧变量的类型，再进行赋值。
示例：
int a = 5;
a += 2.5; // 等价于 a = (int)(a + 2.5); 结果为 7（舍弃小数部分）
注意事项
- 类型兼容性：
若右侧计算结果超出左侧变量类型范围，可能导致数据溢出或精度丢失。 - 代码简洁性：
扩展赋值运算符可简化代码，但需注意隐式类型转换的副作用。 - 复合运算顺序：
运算符优先级低于算术运算符，但高于普通赋值。
错误示例：
int b = 10;
b = b + 0.5; // 报错！需显式强制转换：b = (int)(b + 0.5);
b += 0.5; // 合法，等价于 b = (int)(b + 0.5);
总结
-
基本赋值运算符
=是变量赋值的核心。 -
扩展赋值运算符提供简洁语法，但需注意隐式类型转换的潜在问题。
4. 关系运算符
常见关系运算符及功能
关系运算符用于判断数据是否满足条件，返回布尔值（true/false）。
| 符号 | 例子 | 作用 | 结果说明 |
|---|---|---|---|
> | a > b | 判断 a 是否大于 b | 成立返回 true，否则 false |
>= | a >= b | 判断 a 是否大于或等于 b | 成立返回 true，否则 false |
< | a < b | 判断 a 是否小于 b | 成立返回 true，否则 false |
<= | a <= b | 判断 a 是否小于或等于 b | 成立返回 true，否则 false |
== | a == b | 判断 a 是否等于 b | 成立返回 true，否则 false |
!= | a != b | 判断 a 是否不等于 b | 成立返回 true，否则 false |
示例代码
int a = 10;
int b = 5;
System.out.println(a > b); // 输出：true
System.out.println(a == b); // 输出：false
System.out.println(a != 20); // 输出：true
注意事项
- 比较对象类型：
关系运算符只能用于数值类型（如int、double）或可比较的对象（如String需用.equals()）。 - 浮点数精度问题：
避免直接使用==比较浮点数，可能因精度误差导致错误。double x = 0.1 + 0.2; double y = 0.3; System.out.println(x == y); // 输出：false（实际 x ≈ 0.30000000000000004） - 字符串比较：
==比较的是对象地址，需用.equals()比较内容。String s1 = "Java"; String s2 = new String("Java"); System.out.println(s1 == s2); // 输出：false（地址不同） System.out.println(s1.equals(s2)); // 输出：true（内容相同）
总结
-
关系运算符是逻辑判断的基础工具，返回布尔值驱动条件分支（如
if、while）。 -
注意数值类型与对象类型比较的差异，避免逻辑错误。
5. 三元运算符
基本语法与功能
- 语法格式：
条件表达式 ? 值1 : 值2 - 执行流程：
- 计算条件表达式的结果（
true或false）。 - 结果为
true，返回值1；结果为false，返回值2。
- 计算条件表达式的结果（
示例代码
-
基本用法：比较两个数的大小，返回较大值。
int a = 10; int b = 20; int max = a > b ? a : b; // max = 20 -
条件分支简化：判断奇偶数。
int num = 15; String result = num % 2 == 0 ? "偶数" : "奇数"; // result = "奇数" -
嵌套三元运算符（需谨慎使用，避免可读性降低）：
int score = 85; String grade = score >= 90 ? "A" : (score >= 80 ? "B" : "C"); // grade = "B"
注意事项
-
返回值类型一致性：
值1和值2的类型必须兼容（例如同为数值类型或同一父类派生）。// 合法：同为数值类型 double val = true ? 10 : 3.14; // val = 10.0 // 非法：类型不兼容 // Object obj = true ? "Java" : 100; // 编译错误 -
代码可读性：
- 适用于简单条件判断，复杂逻辑建议使用
if-else。 - 避免多层嵌套，易导致代码难以维护。
- 适用于简单条件判断，复杂逻辑建议使用
-
与
if-else的区别：- 三元运算符必须返回一个值，而
if-else可以执行代码块。 - 三元运算符更简洁，但功能有限。
- 三元运算符必须返回一个值，而
6. 逻辑运算符
逻辑运算符用于组合多个条件，最终返回布尔值（true/false）。
基础逻辑运算符
| 符号 | 名称 | 示例 | 运算逻辑 |
|---|---|---|---|
& | 逻辑与 | a > 1 & b < 5 | 所有条件均为 true 时结果为 true；任一条件为 false，结果为 false |
| | 逻辑或 | a > 1 | b < 5 | 任一条件为 true 时结果为 true；全为 false 时结果为 false |
! | 逻辑非 | !(a > 1) | 对单个条件取反：true 变 false，false 变 true |
^ | 逻辑异或 | a > 1 ^ b < 5 | 条件结果不同时返回 true；相同时返回 false |
示例代码：
boolean x = (5 > 3) & (4 < 6); // true（两个条件均成立）
boolean y = (5 > 3) | (4 > 6); // true（至少一个条件成立）
boolean z = !(5 > 3); // false（对 true 取反）
boolean w = (5 > 3) ^ (4 > 6); // true（条件结果不同）
短路逻辑运算符
| 符号 | 名称 | 示例 | 运算逻辑 |
|---|---|---|---|
&& | 短路与 | a > 1 && b < 5 | 与 & 结果相同，但若左侧为 false，右侧不再执行 |
|| | 短路或 | a > 1 || b < 5 | 与 | 结果相同，但若左侧为 true，右侧不再执行 |
示例代码：
int a = 10;
// 短路与（左侧为 false，右侧不执行）
boolean result1 = (a < 5) && (++a > 0);
System.out.println(a); // 输出：10（右侧未执行）
// 短路或（左侧为 true，右侧不执行）
boolean result2 = (a > 5) || (++a < 20);
System.out.println(a); // 输出：10（右侧未执行）
注意事项
-
执行顺序：
&和|会执行所有条件，无论左侧结果如何。&&和||会根据左侧结果决定是否执行右侧条件。
-
性能优化：
短路运算符（&&、||）可避免不必要的计算，提升代码效率。 -
逻辑异或的实用性：
^常用于需要严格区分条件结果是否一致的场景（如权限校验）。
总结
- 逻辑运算符是复杂条件判断的核心工具。
- 短路运算符在保证结果正确性的同时优化性能，优先使用。
- 注意运算符的副作用（如变量修改），尤其是在非短路运算符中。
扫一扫
1586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
