Java中的优先级

Question

根据优先级表，一元postfix递增和递减运算符比关系运算符具有更多的优先级，那么为什么在这样的表达式（x ++> = 10）中，关系运算符首先求值，然后变量递增？

Answer 1

The operator isn't evaluated first. The ordering is:

• Evaluate LHS ( x++ ) - the result is the original value of x , then x is incremented
• Evaluate RHS ( 10 ) - the result is 10
• Compare the results of the LHS and RHS

Here's code to demonstrate that:

public class Test {

    static int x = 9;

    public static void main(String[] args) {
        boolean result = x++ >= showXAndReturn10();
        System.out.println(result); // False
    }

    private static int showXAndReturn10() {
        System.out.println(x); // 10
        return 10;
    }
}

That prints out 10 then false , because by the time the RHS is evaluated x has been incremented... but the >= operator is still evaluating 9 >= 10 as the result of the expression x++ is the original value of x , not the incremented one.

If you want the result after incrementing, use ++x instead.

Answer 2

The relational operator is not evaluated before the increment.

First the operands of the relational operator ( x++ and 10 ) are evaluated.

However, the evaluation of x++ increments x but returns the original value of x , so even though the increment already took place, the value passed to the relational operator is the original value of x .

Answer 3

Your conclusion is not correct. The x++ is evaluated fist, just its value is the value of x before the increment as defined for the postfix increment operation.

Answer 4

Because this is how "++, --" are working. If it comes after the variable, the old value is used then the value increases, and if it comes before the variable, the increment is occurred first, then the new value is used. So, if you want to use the variable after increasing its value and before you check it, then use (++x >= 10), or increase it without reference and then check it, like that:

int x = 0;
x++;
if(x >= 10) {...}

Answer 5

Unary Operators

However you put the unary operators in an expression, the following table summarize its usage.

+----------+-------------------+------------+-----------------------------------------------------------------------------------+
| Operator |       Name        | Expression |                                    Description                                    |
+----------+-------------------+------------+-----------------------------------------------------------------------------------+
| ++       | prefix increment  | ++a        | Increment "a" by 1, then use the new value of "a" in the residing expression.     |
| ++       | postfix increment | a++        | Use the current value of "a" in the residing expression, then increment "a" by 1. |
| --       | prefix decrement  | --b        | Decrement "b" by 1, then use the new value of "b" in the residing expression.     |
| --       | postfix decrement | b--        | Use the current value of "b" in the residing expression, then decrement "b" by 1. |
+----------+-------------------+------------+-----------------------------------------------------------------------------------+

Then, consider the following java program:

public class UnaryOperators {
    public static void main(String args[]) {
        int n;

        // postfix unary operators
        n = 10;
        System.out.println(n); // prints 10
        System.out.println(n++); // prints 10, then increment by 1
        System.out.println(n); // prints 11

        n = 10;
        System.out.println(n); // prints 10
        System.out.println(n--); // prints 10, then decrement by 1
        System.out.println(n); // prints 9


        // prefix unary operators
        n = 10;
        System.out.println(n); // prints 10
        System.out.println(++n); // increment by 1, then prints 11
        System.out.println(n); // prints 11

        n = 10;
        System.out.println(n); // prints 10
        System.out.println(--n); // decrement by 1, then prints 9
        System.out.println(n); // prints 9
    }
}