评估尊重括号和优先权 - java

Question

As per the Java Language Specification:

Evaluation Respects Parentheses and Precedence

aside from using mathematical operation like:

int i = 3;
int j =  3 * (9 + 3);
System.out.println(j); //results to 36

are there any other examples that this rule apply? I tried using

int i = 0;
int z = 0;
if(i++ < 5 || (++z <0 && 5 > z++) || 6 < ++i){
  System.out.println("Routed here");
}
System.out.println("i: " + i);
System.out.println("z: " + z);

but it results to i: 1 and z:0. It seems that the evaluation on that if example is still from left to right.

Answer 1

With || , Java uses the concept of short circuiting, while evaluating expressions. Therefore, in this:

if(i++ < 5 || (++z <0 && 5 > z++) || 6 < ++i){

since the very first expression i++ < 5 returns true, hence rest of the expression will not be evaluated, ie never visited, hence will bring a change only in the value of i and no other thingy.

Quote from Java Docs:

The Conditional Operators The && and || operators perform Conditional-AND and Conditional-OR operations on two boolean expressions. These operators exhibit "short-circuiting" behavior, which means that the second operand is evaluated only if needed. && Conditional-AND || Conditional-OR The following program, ConditionalDemo1, tests these operators:

class ConditionalDemo1 {

    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if((value1 == 1) && (value2 == 2))
            System.out.println("value1 is 1 AND value2 is 2");
        if((value1 == 1) || (value2 == 1))
            System.out.println("value1 is 1 OR value2 is 1");
    }
}

Answer 2

Parentheses and precedence don't have anything to do with the order in which expressions are evaluated at run time. That is, if you think putting parentheses around an expression means that it will get evaluated earlier, or that an operator with higher precedence is evaluated earlier, you're misunderstanding the concept.

Operator precedence answers questions like this: In the expression

a * b + c

Which operator does the compiler "bind" to arguments first? If + had a higher precedence, it would grab the arguments near it before * could, so to speak; so that the result would be that b and c are added, and the result is multiplied by a . That is, it would be equivalent to

a * (b + c)

But in most programming languages (with some exceptions such as APL), the * has higher precedence. That means the arguments are bound to * before they're bound to + , which means that a and b are multiplied, and the result is added to c , ie

(a * b) + c

Similarly, in the expression

a + b * c

the result is that b and c are multiplied, and the result is added to a .

a + (b * c)

You can put parentheses around parts of the expressions to change how the arguments are bound; thus, if you want to add a and b and multiply the sum by c , you can say

(a + b) * c

But it's very important to note: All this controls how the expression is interpreted at compile time. But at runtime, the arguments are always evaluated left-to-right. When the program is run, ALL of the above expressions will cause the program to evaluate a , then b , then c . This doesn't matter if a , b , and c are variables, but if they were method calls, it could possibly matter. In Java, when the program is run, things are always evaluated from left to right. (This is not true of other languages; most languages that I know of let the compiler choose the order.)

And when it comes to || and && (or similar operators in some other languages), once again at run time, the left argument is always evaluated first. The right argument may or may not be evaluated. Parentheses and operator precedence control how the expression is interpreted if you have an expression like some-expression-1 || some-expression-2 && some-expression-3 some-expression-1 || some-expression-2 && some-expression-3 , but they do not change the order of evaluation at run time.

Answer 3

As soon as the test can be evaluated to true or false the execution jumps inside the if block. In your case, i equals 0 which is lighter than than 5 so the test evaluates to true .

(true OR a OR b) is true independently from the values of a and b , which are not evaluated (and incrementations are not applied).

It would be the same with (false AND a AND b) except it would always skip the block.

Check the order of your expressions, split them into separate tests or get your incrementations out of the test. The following code is equivalent to your example but with the output you expected :

int i = 0;
int z = 1;
if(i < 5 || (z < 0 && 5 > z+2) || 6 < i+2){
  System.out.println("Routed here");
}
i += 2;
z += 2;
System.out.println("i: " + i);
System.out.println("z: " + z);