Page History

Programmers frequently make errors regarding the precedence of operators because of the unintuitive unintuitively low - precedence levels of &, |, ^, <<, and >>. Avoid mistakes regarding precedence through the suitable use of parentheses. This , which also improves code readability unless taken to excess. The precedence of operations by the order of the subclauses are is defined in the Java Tutorials [Tutorials 20082013].

Although it advises against depending on parentheses for specifying evaluation order , EXP05-J. Do not write more than once to the same variable follow a write by a subsequent write or read of the same object within an expression applies only to expressions that contain side effects.

Noncompliant Code Example

The intent of the expression in this noncompliant code example is to add the variable OFFSET to the result of the bitwise logical AND between x and MASK.:

Code Block

bgColor	#FFCCCC

public static final int MASK = 1337;
public static final int OFFSET = -1337;

public static int computeCode(int x) {
  return x & MASK + OFFSET;
}

...

Code Block
x & (MASK + OFFSET)

This expression gets is evaluated , as follows, resulting in the value 0.:

Code Block
x & (1337 - 1337)

Compliant Solution

This compliant solution uses parentheses to ensure that the expression evaluates is evaluated as intended.:

Code Block

bgColor	#ccccff

public static final int MASK = 1337;
public static final int OFFSET = -1337;

public static int computeCode(int x) {
  return (x & MASK) + OFFSET;
}

Noncompliant Code Example

In this noncompliant code example, the intent is to add append either "0" or "1" to the string "value=".:

Code Block

bgColor	#FFCCCC

public class PrintValue Test{
    public static void main(String[] args) {
        String s = null;
    // Prints "1"
    System.out.println("value=" + s == null ? 0 : 1); // prints "1"
    }
}

However, the precedence rules result in the expression to be printed being parsed as ("value=" + s) == null ? 0 : 1.

Compliant Solution

This compliant solution uses parentheses to ensure that the expression evaluates as intended.:

Code Block

bgColor	#ccccff

public class PrintValue Test{
    public static void main(String[] args) {
        String String s = null;
    // Prints "value=0" as expected
   System System.out.println("value=" + (s == null ? 0 : 1)); // prints "value=0" as expected
    }
}

Applicability

Mistakes regarding precedence guidelines can cause an expression to be evaluated in an unintended way. This , which can lead to unexpected and abnormal program behavior.

Parentheses may be omitted from mathematical expressions that follow the algebraic precedence rules. For instance, consider the following expression:

Code Block
x + y * z

By mathematical convention, multiplication is performed before addition; parentheses are redundant in this case.:

Code Block

bgColor	#FFCCCC

x + (y * z)

Detection of all expressions using low-precedence operators without parentheses is straightforward. Determining the correctness of such uses is infeasible in the general case; , although heuristic warnings could be useful.