Operator Precedence

A school program needs reliable data and clear rules. Precedence determines how operators group when parentheses are absent. Multiplication groups before addition, so the placement of parentheses can change a marks calculation.

In Java, when you write a complex expression involving multiple operators, the order in which those operators are evaluated is governed by a set of rules called operator precedence.

If you've ever wondered why 2 + 3 * 4 doesn't equal 20, then operator precedence is the reason.

Operator precedence determines the order in which different operators in an expression are evaluated. For instance, multiplication has higher precedence than addition, so it is performed first.

When two operators have the same precedence, associativity determines the direction of evaluation. It can be either:

• Left-to-right: Most binary operators (e.g., +, -, *, /)
• Right-to-left: Unary, assignment, and ternary operators

Here’s a simplified view of Java operators from highest to lowest precedence:

public class Main {
  public static void main(String[] args) {
    int result = 10 + 2 * 3;
    System.out.println("Result: " + result);
  }
}

Result: 16

Explanation: 2 * 3 is evaluated first (due to higher precedence), and then 10 + 6 is evaluated.

public class Main {
  public static void main(String[] args) {
    int result = (10 + 2) * 3;
    System.out.println("Result: " + result);
  }
}

Result: 36

Explanation: By wrapping 10 + 2 in parentheses, we change the natural order of evaluation.

public class Main {
  public static void main(String[] args) {
    int a = 20, b = 10, c = 5;
    int result = a - b - c;
    System.out.println("Result: " + result);
  }
}

Result: 5

Explanation: Since - has left-to-right associativity, evaluation happens like (20 - 10) - 5.

public class Main {
  public static void main(String[] args) {
    int a, b, c;
    a = b = c = 100;
    System.out.println(a + " " + b + " " + c);
  }
}

100 100 100

Explanation: Assignment operators are evaluated from right to left: c = 100, then b = c, then a = b.

public class Main {
  public static void main(String[] args) {
    boolean result = true || false && false;
    System.out.println(result);
  }
}

true

Explanation: && has higher precedence than ||, so false && false is evaluated first (which is false), then true || false becomes true.

Even a minor mistake in understanding precedence can lead to incorrect logic and subtle bugs. Always use parentheses to make your intent clear, especially in complex conditions or calculations.

• Use parentheses generously for clarity, not just correctness.
• Always know your associativity when chaining operators.
• Don’t rely solely on precedence—aim for readable, maintainable code.

Precedence groups expressions; it is not a reason to rely on complicated side effects. Add parentheses when they clarify the intended calculation.

Before running this Java program, write down each line you expect to see. Identify the value, branch, object or exception responsible for each line. Then explain whether the following assumption is valid: Precedence groups expressions; it is not a reason to rely on complicated side effects.

Java 17 · Main.java · complete practice program

public class Main  {
  public static void main(String[] args)  {
    System.out.println(10 + 5 * 2);
    System.out.println((10 + 5) * 2);
  }
}

Now change one thing: Replace the initial 10 with 20. Predict the new behavior before checking the worked variation.

Java 17 · Main.java · source repeated for this answer

public class Main  {
  public static void main(String[] args)  {
    System.out.println(10 + 5 * 2);
    System.out.println((10 + 5) * 2);
  }
}

Expected output

20
30

Precedence determines how operators group when parentheses are absent. Multiplication groups before addition, so the placement of parentheses can change a marks calculation.

Precedence groups expressions; it is not a reason to rely on complicated side effects. Add parentheses when they clarify the intended calculation.

Run with javac Main.java, then java Main. The declaration of Main names the class; main starts the example, and println writes a complete output line.

Worked variation: Replace the initial 10 with 20. The two expressions produce 30 and 50, respectively.

Precedence determines how operators group when parentheses are absent. Multiplication groups before addition, so the placement of parentheses can change a marks calculation. Precedence groups expressions; it is not a reason to rely on complicated side effects. Add parentheses when they clarify the intended calculation.

Related explanations: Java Variables, Java If Statement - Syntax and Examples, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide and Java 17 language specification.