Java 运算符优先级与结合性：避免常见逻辑错误，拯救你的代码！
各位Javaer，大家好！今天咱们来聊聊一个看似不起眼，但却能让你掉进逻辑陷阱的家伙：Java运算符的优先级与结合性。别小看它们，掌握不好，你的代码就会像喝了假酒的哈士奇，跑偏得让你哭笑不得。
想象一下，你辛辛苦苦写了一段代码，自信满满地运行，结果却发现输出的结果和你预期的完全不一样。抓耳挠腮，debug半天，最后发现竟然是因为运算符优先级搞错了！这种感觉，就像精心准备的约会，结果发现对方穿了你的旧秋裤一样尴尬。
所以，为了避免这种惨剧发生，让我们一起深入了解Java运算符的优先级与结合性，彻底驯服它们，让它们乖乖地为我们服务。
一、 什么是运算符优先级？
简单来说，运算符优先级决定了表达式中哪个运算符先执行，哪个后执行。就像数学中的先乘除后加减一样，Java也有自己的一套运算符优先级规则。
举个例子：
int result = 2 + 3 * 4;
System.out.println(result); // 输出 14在这个例子中，* 运算符的优先级高于 + 运算符，所以先计算 3 * 4，得到 12，然后再计算 2 + 12，最终结果是 14。
如果我们希望先计算 2 + 3，然后再乘以 4，该怎么办呢？很简单，使用括号：
int result = (2 + 3) * 4;
System.out.println(result); // 输出 20括号可以改变运算符的优先级，强制先执行括号内的运算。
二、 Java运算符优先级表格
为了方便大家查阅，我整理了一份Java运算符优先级表格，从高到低排列：
| 优先级 | 运算符 | 描述 | 结合性 |
|---|---|---|---|
| 1 | [], . , () (方法调用) |
数组下标访问、成员访问、方法调用。注意：() 作为分组运算符时，优先级最高。 |
从左到右 |
| 2 | ++, --, !, ~, + (单目), - (单目), (type)new |
一元运算符，包括自增、自减、逻辑非、位非、正号、负号、强制类型转换、创建对象。 | 从右到左 |
| 3 | *, /, % |
乘法、除法、取模。 | 从左到右 |
| 4 | +, - |
加法、减法。 | 从左到右 |
| 5 | <<, >>, >>> |
左移、右移、无符号右移。 | 从左到右 |
| 6 | <, <=, >, >=, instanceof |
关系运算符，小于、小于等于、大于、大于等于、类型判断。 | 从左到右 |
| 7 | ==, != |
相等、不相等。 | 从左到右 |
| 8 | & |
位与。 | 从左到右 |
| 9 | ^ |
位异或。 | 从左到右 |
| 10 | | |
位或。 | 从左到右 |
| 11 | && |
逻辑与。 | 从左到右 |
| 12 | || |
逻辑或。 | 从左到右 |
| 13 | ?: |
三元运算符。 | 从右到左 |
| 14 | =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>= |
赋值运算符。 | 从右到左 |
记住这个表格很重要，但更重要的是理解它背后的逻辑。 不用死记硬背，多写代码，多练习，自然就能记住。
三、 什么是结合性？
当表达式中出现多个相同优先级的运算符时，结合性决定了运算的顺序。Java的结合性分为两种：
- 从左到右： 表达式从左向右依次计算。
- 从右到左： 表达式从右向左依次计算。
举个例子：
int a = 10;
int b = 20;
int c = 30;
int result = a = b = c;
System.out.println(result); // 输出 30
System.out.println(a); // 输出 30
System.out.println(b); // 输出 30
System.out.println(c); // 输出 30在这个例子中，= 赋值运算符的结合性是从右到左，所以先计算 b = c，将 c 的值赋给 b，然后计算 a = b，将 b 的值赋给 a。最终，a、b、c 的值都变成了 30。
再看一个例子：
int x = 1;
int y = 2;
System.out.println(x - y + x); // 输出 0在这个例子中， + 和 - 运算符的优先级相同，结合性是从左到右，所以先计算 x - y，得到 -1，然后再计算 -1 + x，最终结果是 0。
四、 常见逻辑错误及避免方法
了解了运算符优先级和结合性，我们就可以避免很多常见的逻辑错误。下面列举一些常见的错误，并给出避免方法：
1. 赋值运算符的返回值
很多新手容易忽略赋值运算符的返回值。赋值运算符的返回值是被赋的值。
int a;
if ((a = 5) > 3) {
System.out.println("a is greater than 3"); // 输出 "a is greater than 3"
}
System.out.println(a); // 输出 5在这个例子中，(a = 5) 的返回值是 5，所以 if 条件成立。
错误示例：
int a = 1;
int b = 2;
if (a = b == 3) { // 错误的写法
System.out.println("This will not be printed");
}在这个错误示例中，b == 3 的优先级高于 a = b，所以先计算 b == 3，结果是 false (0)，然后将 false (0) 赋值给 a。因为 a 的值是 0，所以 if 条件不成立。
正确写法：
int a = 1;
int b = 2;
if ((a = b) == 3) { // 正确的写法
System.out.println("This will not be printed");
}使用括号明确运算顺序，先将 b 的值赋给 a，然后再判断 a 是否等于 3。
2. 位运算符与逻辑运算符的混淆
位运算符 (&, |, ^) 和逻辑运算符 (&&, ||) 虽然看起来相似，但作用完全不同。位运算符是对二进制位进行操作，而逻辑运算符是对布尔值进行操作。
错误示例：
int a = 5; // 二进制 0101
int b = 3; // 二进制 0011
if (a & b == 1) { // 错误的写法
System.out.println("This will not be printed");
}在这个错误示例中，a & b 的结果是 1 (二进制 0001)，但是 a & b == 1 的优先级高于 a & b，所以先计算 b == 1，结果是 false (0)，然后计算 a & 0，结果是 0，所以 if 条件不成立。
正确写法：
int a = 5; // 二进制 0101
int b = 3; // 二进制 0011
if ((a & b) == 1) { // 正确的写法
System.out.println("This will be printed");
}使用括号明确运算顺序，先计算 a & b，然后再判断结果是否等于 1。
3. 自增自减运算符的位置
自增自减运算符 (++, --) 放在变量前面和后面，效果不同。
++i(前缀)：先自增，再返回值。i++(后缀)：先返回值，再自增。
示例：
int i = 5;
int j = ++i; // i = 6, j = 6
System.out.println("i = " + i + ", j = " + j);
int k = 5;
int l = k++; // k = 6, l = 5
System.out.println("k = " + k + ", l = " + l);错误示例：
int x = 0;
int y = x++ + ++x; // 结果不确定，取决于编译器
System.out.println(y);在这个错误示例中，x++ + ++x 的结果是不确定的，因为不同的编译器可能会以不同的顺序计算自增运算符。
避免方法：
尽量避免在同一个表达式中多次使用自增自减运算符，特别是当它们影响同一个变量时。如果需要多次自增自减，最好分成多个语句来写，以提高代码的可读性和可维护性。
4. 类型转换的优先级
强制类型转换运算符 (type) 的优先级很高，需要特别注意。
错误示例：
double x = 10.5;
int y = (int) x + 5.5; // 错误的写法
System.out.println(y); // 输出 15在这个错误示例中，(int) x 只转换了 x 的整数部分，结果是 10，然后计算 10 + 5.5，结果是 15.5，最后将 15.5 赋值给 y，发生了隐式类型转换，只保留了整数部分 15。
正确写法：
double x = 10.5;
int y = (int) (x + 5.5); // 正确的写法
System.out.println(y); // 输出 16使用括号明确运算顺序，先计算 x + 5.5，结果是 16，然后再将结果强制转换为 int 类型。
五、 总结与建议
Java运算符优先级和结合性是编写正确代码的基础。掌握它们，可以避免很多常见的逻辑错误，提高代码的可读性和可维护性。
以下是一些建议：
- 熟记运算符优先级表格： 没事的时候可以多看看，加深印象。
- 使用括号明确运算顺序： 当你不确定运算符优先级时，或者为了提高代码的可读性，可以使用括号来明确运算顺序。
- 避免复杂的表达式： 尽量将复杂的表达式分解成多个简单的语句，以提高代码的可读性和可维护性。
- 多写代码，多练习： 实践是检验真理的唯一标准。通过多写代码，多练习，你才能真正掌握Java运算符优先级和结合性。
- 使用静态代码分析工具： 静态代码分析工具可以帮助你发现代码中的潜在问题，包括运算符优先级错误。
最后，记住一点：代码是写给人看的，顺便让机器执行。 编写清晰、易懂的代码，比追求代码的简洁更重要。
希望这篇文章能帮助你更好地理解Java运算符优先级和结合性，写出更健壮、更可靠的代码。祝大家编程愉快！