Operators in Java

A. Classification by Operand Count:

• Unary Operators: Operate on a single operand. (e.g., Unary plus +a, Unary minus -a, Increment ++a, Decrement --a, Logical NOT !flag).
• Binary Operators: Operate on two operands. (e.g., Addition a + b, Multiplication a * b, Equality a == b, Logical AND a && b).
• Ternary Operator: Operates on three operands. In Java, there is only one ternary operator: the Conditional Operator (condition ? expr1 : expr2).

B. Arithmetic Operators (The Calculation Engine):

Modulus Sign Rule: The result of a % b always carries the algebraic sign of the numerator (first operand): -10 % 3 = -1; 10 % -3 = 1; -10 % -3 = -1.

A. The Fundamental Distinction:

• Prefix Form (++x / --x): Change-Then-Use
  The value of the variable is incremented (or decremented) by 1 first, and the new updated value is then used in the surrounding expression.
• Postfix Form (x++ / x--): Use-Then-Change
  The current original value of the variable is used in the surrounding expression first, and only after the evaluation is the variable incremented (or decremented) by 1 in memory.

B. Step-by-Step Evaluation Trace Table (Classic ICSE Question):

Problem: If int a = 5, b = 3; evaluate: int c = ++a * 2 + b++ * --a - a--;

Mathematical Substitution: c = (6 * 2) + (3 * 5) - 5;
c = 12 + 15 - 5 = 22;
Final Variable States: c = 22, a = 4, b = 4.

A. Relational Operators (Produce boolean):

Used to compare two numerical or character values: == (Equal to), != (Not equal to), >, <, >=, <=.

B. Logical Operators & Short-Circuit Behavior:

• Logical AND (&&): Returns true if and only if both operands are true.
  Short-Circuit Rule: If the left operand evaluates to false, the overall expression can never be true. Therefore, Java skips evaluating the right operand entirely!
  Example: if (x != 0 && (100 / x) > 5) → If x == 0, the division is never attempted, safely preventing an ArithmeticException: / by zero!
• Logical OR (||): Returns true if at least one operand is true.
  Short-Circuit Rule: If the left operand evaluates to true, the overall expression is already guaranteed true. Java skips evaluating the right operand!
• Logical NOT (!): Unary operator that inverts truth value (!true = false; !false = true).

A. Syntax and Mechanics:

variable = (condition) ? expression_if_true : expression_if_false;

The condition is evaluated first. If it yields true, expression_if_true is evaluated and returned; otherwise, expression_if_false is evaluated and returned.

B. Conversion from if-else to Ternary:

if (marks >= 40)
    result = "Pass";
else
    result = "Fail";

result = (marks >= 40) ? "Pass" : "Fail";

if (a > b)
    max = (a > c) ? a : c;
else
    max = (b > c) ? b : c;

max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);

Evaluation Hierarchy (Highest to Lowest):

Problem 1: Complex Postfix & Prefix Combination

Expression: If int x = 10, y = 12; evaluate: int z = ++x * (y++ - --x) + y--;

• ++x: x changes from 10 to 11. (Value used: 11)
• y++: y is currently 12, then increments to 13. (Value used: 12)
• --x: x changes from 11 to 10. (Value used: 10)
• Inside parentheses: (12 - 10) = 2.
• y--: y is currently 13, then decrements to 12. (Value used: 13)
• Evaluation: z = 11 * 2 + 13 = 22 + 13 = 35.
• Final States: z = 35, x = 10, y = 12.

Problem 2: Cascading Increment and Relational Evaluation

Expression: If int a = 4, b = 7; evaluate: boolean flag = (++a * 3 > b--) && (a++ + --b < 15);

• Left operand: ++a makes a = 5. (Value: 5). b-- uses 7, then b becomes 6.
• Left comparison: (5 * 3 > 7) → (15 > 7) → true.
• Since left of && is true, right side must be evaluated!
• Right operand: a++ uses 5, then a becomes 6. --b decrements b from 6 to 5 (Value: 5).
• Right comparison: (5 + 5 < 15) → (10 < 15) → true.
• Overall: true && true → true.
• Final States: flag = true, a = 6, b = 5.

Exhaustive Step-by-Step Expression Solving:

Drill 1: If int m = 12; evaluate: m = m++ + ++m - m-- + --m;

• m++: uses 12, m becomes 13.
• ++m: m becomes 14, uses 14.
• m--: uses 14, m becomes 13.
• --m: m becomes 12, uses 12.
• Result: m = 12 + 14 - 14 + 12 = 24.

Drill 2: If int a = 5, b = 2; evaluate: int res = a++ * 2 + --b * a;

• a++ uses 5, then a becomes 6.
• --b decrements b from 2 to 1, uses 1.
• Subsequent a is now 6.
• Math: (5 * 2) + (1 * 6) = 10 + 6 = 16.
• Final states: res = 16, a = 6, b = 1.

Drill 3: If int x = 7; evaluate: x += x++ + ++x + x;

• Original x = 7. Right side: x++ uses 7, x becomes 8. ++x becomes 9, uses 9. Final x = 9.
• Sum: 7 + 9 + 9 = 25.
• x += 25 → x = 7 + 25 = 32.

A. Bit-Level Manipulation Operators:

Step-by-Step Expression Solving:

Problem 4: If int a = 10, b = 20; evaluate: int c = a++ + ++b * --a / 5;

• a++ uses 10, a becomes 11.
• ++b increments b from 20 to 21, uses 21.
• --a decrements a from 11 back to 10, uses 10.
• Multiplicative precedence (* and / have equal precedence, evaluated left to right):
• 21 * 10 = 210
• 210 / 5 = 42
• Addition: c = 10 + 42 = 52.
• Final Output: c = 52, a = 10, b = 21.

Problem 5: If int x = 3; evaluate: x = x++ * x++ * ++x;

• First x++ uses 3, x becomes 4.
• Second x++ uses 4, x becomes 5.
• ++x increments x from 5 to 6, uses 6.
• Math: x = 3 * 4 * 6 = 72.
• Final Output: x = 72.

A. Logical Operator Truth Table (A, B boolean):

B. Assignment vs Equality Comparison:

The single equals sign = is the Assignment Operator that stores the value of the right-hand operand into the left-hand variable (e.g., int x = 10;). The double equals sign == is the Relational Equality Operator that compares two values and returns a boolean (true or false). In Java, writing if (x = 10) triggers a compilation error because Java strictly forbids assigning integers inside conditional expressions.

A. Shorthand Assignment Operators:

Compound assignment operators combine an arithmetic or bitwise operation with assignment: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=.

Implicit Casting Advantage: In Java, compound assignment operators perform an implicit type cast automatically! For example, if byte b = 10;, writing b = b + 1; fails to compile because b + 1 evaluates to an int. However, writing b += 1; is completely legal because it is equivalent to b = (byte)(b + 1);.

Always remember that expressions inside parentheses are evaluated with the highest priority. When evaluating complex boolean logic, break the expression into distinct relational sub-conditions and evaluate them according to strict operator hierarchy, respecting short-circuit evaluation for AND and OR operators.

In all complex expressions, multiplication, division, and modulus operations always take precedence over addition and subtraction. When operations have identical precedence levels, evaluation proceeds strictly from left to right, except for assignment, unary, and ternary operators which evaluate from right to left.