运算符优先级
本教程共 100 篇 · 第 15 篇 · 更新于 2026-08-05 · 约 5 分钟阅读
15. 运算符优先级
本节目标：理解优先级决定表达式里谁先算，记住最常用的几条高低顺序，并养成「拿不准就加括号」的安全习惯。
为什么要有优先级
一个表达式里同时出现多个运算符，总得有个规矩决定谁先算。这个规矩就是优先级。
比如数学里 1 + 2 * 3，人人都知道先乘后加，得 7 而不是 9。Java 也一样：* 的优先级比 + 高，所以先算 2 * 3。
int r = 1 + 2 * 3; // 先算 2*3=6，再 1+6=7
System.out.println(r); // 7
```bash
## 死记不如用括号
完整的优先级表有十几级，没人会去背。真正的高手也不背——他们有个更省事的习惯：**拿不准，就加括号**。
括号 `( )` 的优先级最高，能强制改变计算顺序，而且让读代码的人一眼看懂你的意图：
```java
int r1 = 1 + 2 * 3; // 7
int r2 = (1 + 2) * 3; // 9，括号强制先算加法两段一对比，哪个好懂不言而喻。写代码是给人看的，括号是性价比最高的「防歧义神器」。
最常用的几条高低顺序
虽然不用背全表，但有几条高频顺序值得记在心里（从上到下，优先级由高到低）：
- 一元运算符：
++--!-（正负号） - 乘除取余：
*/% - 加减：
+- - 关系比较：
<><=>= - 相等判断：
==!= - 逻辑与：
&& - 逻辑或：
|| - 三元运算符：
?: - 赋值：
=
抓住一个主干就够用：先乘除后加减，先比较后逻辑，逻辑里 && 比 || 急，赋值永远最后。
一个经典易错点
&& 比 || 优先级高，这会让下面这种写法出人意料：
boolean result = true || false && false;
```java
因为 `&&` 先算，`false && false` 得 `false`，再算 `true || false` 得 `true`。如果你本意是「先算 `true || false` 再和 `false` 与」，结果就错了。
加括号让意图一目了然：
```java
boolean result = true || (false && false); // 明确：true
boolean other = (true || false) && false; // 明确：falseWarning涉及
&&和||混用时，强烈建议加括号。这俩优先级不同，混写不加括号，半年后你自己都看不懂当初想表达什么。
数学里的连写，Java 里不认
数学里常写 1 < x < 10 表示「x 在 1 和 10 之间」。但 Java 不支持这种连写，如果你直接敲：
// if (1 < x < 10) // 编译报错！
```java
Java 会先算 `1 < x`，得到一个 `boolean`，再拿这个 `boolean` 去和 `10` 比大小——类型对不上，直接报错。
正确写法是拆成两个比较，用 `&&` 连接：
```java
if (1 < x && x < 10) { // 正确：x 大于 1 且 小于 10
System.out.println("在区间内");
}这是个从数学思维切换到编程思维时极容易栽的跟头，记住：范围判断永远拆成两个比较再用逻辑运算符连起来。
一元符号也有优先级
负号 - 作为一元运算符，优先级比乘除还高。所以 -a * b 等于 (-a) * b，而不是 -(a * b) 之外的意外——其实两者在这里结果一样，但一元负号确实先于 * 生效。写 -2 * 3 得到 -6，符合直觉，只是要知道这条规则存在。
结合性：同级运算符谁先算
优先级解决「不同运算符谁先」，结合性解决「同一级的好几个运算符，谁先谁后」。
Java 里绝大多数运算符是左结合的，也就是从左到右算：
int x = 10 - 3 - 2; // 先算 10-3=7，再 7-2=5（左结合）
```text
唯一的例外是**赋值运算符右结合**：`a = b = c` 从右往左，等价于 `a = (b = c)`。
```java
int a, b, c;
a = b = c = 100; // 三个都变成 100一元运算符 ++/--（前置时）和 ! 也是右结合，但日常影响很小，记住赋值右结合就够了。
一个综合例子
把前面几条揉在一起看：
int x = 2, y = 3, z = 4;
int r = x + y * z > 10 && y - 1 == 2 ? 1 : 0;
```bash
按优先级拆解：`y*z` 先（12）→ `x+12` 得 14 → `14 > 10` 得 `true` → `y-1` 得 2 → `2 == 2` 得 `true` → `true && true` 得 `true` → 三元取 `1`。最终结果是 `1`。
这种一行塞满运算符的写法可读性很差。真实代码会拆开或加括号，让人喘得过气。
## 完整一点的优先级阶梯
前面那几条主干够日常用了。如果你想看更细的全貌，下面这张表把常见运算符按从高到低排了一遍（同一行优先级相同）：
| 层级 | 运算符 |
|------|--------|
| 最高 | 后缀 `++` `--`（如 `i++`） |
| | 一元前缀 `++` `--` `+` `-` `!` `~` |
| | 乘性 `*` `/` `%` |
| | 加性 `+` `-` |
| | 移位 `<<` `>>` `>>>` |
| | 关系 `<` `>` `<=` `>=` `instanceof` |
| | 相等 `==` `!=` |
| | 逻辑与 `&`、`^`、`|`、`&&`、`||` |
| | 三元 `?:` |
| 最低 | 赋值 `=` 及其复合形式 `+=` `-=` 等 |
看着长，但真正天天打的就中间那几行。表的作用是「拿不准时查一下」，不是背下来。
## 更多易错例子
把前面讲的点用例子再砸实一遍，印象更深。
**加减与比较混写**：`a + b < c + d` 先算两个加法，再比大小。因为算术高于关系，这里不用括号也安全。
**赋值返回值是关键**：`if (x = 5)` 这类写法在 Java 里，`x = 5` 这个赋值表达式的「值」是 5，而 `if` 要求里面是 `boolean`。所以 `if (x = 5)` 编译器直接报错——这反而是好事，帮你拦住了把 `==` 写成 `=` 的错误。
**三元里再套三元要括号**：`a ? b : c ? d : e` 的绑定顺序容易歧义，老老实实加括号 `(a ? b : (c ? d : e))` 才清楚。
## 括号不是越多越好，但要让人安心
有人为了「绝对安全」，给每行都裹满括号，反而看得眼晕：
```java
int r = (((a) + (b)) * (c)); // 过度了括号该用在「顺序不明显、或为了提醒读代码的人」的地方。那种一眼就懂的优先级（如先乘后加），不必硬加。一句话：括号是给人看的说明书，不是保险箱。
小结
优先级决定表达式里谁先算。* / % 高于 + -，比较高于逻辑，&& 高于 ||，赋值最低。
绝大多数运算符左结合，赋值右结合（a = b = c 从右）。
拿不准就加括号——既保证正确，又让意图清晰，是最稳的做法。