运算符优先级

为什么要有优先级

一个表达式里同时出现多个运算符，总得有个规矩决定谁先算。这个规矩就是优先级。

比如数学里 1 + 2 * 3，人人都知道先乘后加，得 7 而不是 9。Java 也一样：* 的优先级比 + 高，所以先算 2 * 3。

int r = 1 + 2 * 3;   // 先算 2*3=6，再 1+6=7
System.out.println(r);  // 7

死记不如用括号

完整的优先级表有十几级，没人会去背。真正的高手也不背——他们有个更省事的习惯：拿不准，就加括号。

括号 ( ) 的优先级最高，能强制改变计算顺序，而且让读代码的人一眼看懂你的意图：

int r1 = 1 + 2 * 3;        // 7
int r2 = (1 + 2) * 3;      // 9，括号强制先算加法

两段一对比，哪个好懂不言而喻。写代码是给人看的，括号是性价比最高的「防歧义神器」。

最常用的几条高低顺序

虽然不用背全表，但有几条高频顺序值得记在心里（从上到下，优先级由高到低）：

1. 一元运算符：++ -- ! -（正负号）
2. 乘除取余：* / %
3. 加减：+ -
4. 关系比较：< > <= >=
5. 相等判断：== !=
6. 逻辑与：&&
7. 逻辑或：||
8. 三元运算符：?:
9. 赋值：=

抓住一个主干就够用：先乘除后加减，先比较后逻辑，逻辑里 && 比 || 急，赋值永远最后。

一个经典易错点

&& 比 || 优先级高，这会让下面这种写法出人意料：

boolean result = true || false && false;

因为 && 先算，false && false 得 false，再算 true || false 得 true。如果你本意是「先算 true || false 再和 false 与」，结果就错了。

加括号让意图一目了然：

boolean result = true || (false && false);  // 明确：true
boolean other   = (true || false) && false;  // 明确：false

数学里的连写，Java 里不认

数学里常写 1 < x < 10 表示「x 在 1 和 10 之间」。但 Java 不支持这种连写，如果你直接敲：

// if (1 < x < 10)   // 编译报错！

Java 会先算 1 < x，得到一个 boolean，再拿这个 boolean 去和 10 比大小——类型对不上，直接报错。

正确写法是拆成两个比较，用 && 连接：

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（左结合）

唯一的例外是赋值运算符右结合：a = b = c 从右往左，等价于 a = (b = c)。

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;

按优先级拆解：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)) 才清楚。

括号不是越多越好，但要让人安心

有人为了「绝对安全」，给每行都裹满括号，反而看得眼晕：

int r = (((a) + (b)) * (c));   // 过度了

括号该用在「顺序不明显、或为了提醒读代码的人」的地方。那种一眼就懂的优先级（如先乘后加），不必硬加。一句话：括号是给人看的说明书，不是保险箱。

小结

优先级决定表达式里谁先算。* / % 高于 + -，比较高于逻辑，&& 高于 ||，赋值最低。

绝大多数运算符左结合，赋值右结合（a = b = c 从右）。

拿不准就加括号——既保证正确，又让意图清晰，是最稳的做法。