Arithmetic operators are used in mathematical expressions and behave as they do in algebra. Assuming integer variables x = 10 and y = 20:

Increment and Decrement Operators

These unary operators modify a single operand. The placement determines evaluation order:

• Prefix (++a, --a): Modify first, then use the new value.
• Postfix (a++, a--): Use the current value first, then modify.

public class IncrementExample {
    public static void main(String[] args) {
        int m = 5;
        int n = ++m; // m becomes 6, then assigned to n
        int p = 5;
        int q = p++; // q gets 5, then p becomes 6
        System.out.println("Prefix result: " + n);  // 6
        System.out.println("Postfix result: " + q); // 5
    }
}

Relational Operators

Used to compare two values, returning a boolean. With x = 10, y = 20:

Bitwise Operators

Operate on individual bits of integer types. Given a = 60 (0011 1100) and b = 13 (0000 1101):

Logical Operators

Work with boolean values. Assuming p = true, q = false:

Short-circuit behavior: In a && b, if a is false, b is not evaluated. Similarly, in a || b, if a is true, b is skipped.

Assignment Operators

Combine an operation with assignment:

Conditional (Ternary) Operator

Syntax: condition ? valueIfTrue : valueIfFalse. It evaluates a boolean and returns one of two values.

instanceof Operator

Checks if an object is an instance of a specific class or interface:

class Vehicle {}
class Car extends Vehicle {}

public class InstanceCheck {
    public static void main(String[] args) {
        Vehicle v = new Car();
        System.out.println(v instanceof Car);   // true
        System.out.println(v instanceof Vehicle); // true
    }
}

Operator Precedence

When multiple operators appear in an expression, precedenec determines evaluation order. Higher precedance operators are evaluated first. Associativity resolves ties.