Operator Taxonomy

Java provides a comprehensive set of built-in operators used to manipulate data and control program flow. These symbols are categorized by their primary function:

Category	Supported Symbols
Arithmetic	+, -, *, /, %, ++, --
Relational	<, >, <=, >=, ==, !=
Logical	&, |, !, ^, &&, ||
Bitwise	&, |, ~, ^, >>, <<, >>>
Assignment	=, +=, -=, *=, /=, %=
String Concatenation	+
Ternary/Conditional	? :
Special/Type Checks	instanceof, new

Arithmetic Calculations

Arithmetic operators perform standard mathematical computations. Integer division truncates fractional parts, meaning the result retains the integer data type.

Symbol	Operation
+	Adddition / String concatenation
-	Subtraction
*	Multiplication
/	Division (enteger or floating-point)
%	Modulus (remainder)
++	Increment by one
--	Decrement by one

Increment/Decrement Placement Matters:

• i++ (Postfix): Assigns the original value first, then increments the variable.
• ++i (Prefix): Increments the variable immediately, then assigns the updated value.

Best Practice: Rely on explicit parentheses to dictate evaluation sequence instead of relying on implicit operator precedence rules.

public class MathOperations {
    public static void main(String[] args) {
        int numerator = 17;
        int denominator = 5;

        System.out.println(numerator + denominator); // 22
        System.out.println(numerator - denominator); // 12
        System.out.println(numerator * denominator); // 85
        System.out.println(numerator / denominator); // 3 (decimal part discarded)
        System.out.println(numerator % denominator); // 2

        System.out.println("--- Increment Behavior ---");
        int baseCounter = 9;
        int assignThenIncrement = baseCounter++; 
        System.out.println("baseCounter: " + baseCounter);   // 10
        System.out.println("assignThenIncrement: " + assignThenIncrement); // 9

        int baseCounter2 = 9;
        int incrementThenAssign = ++baseCounter2;
        System.out.println("baseCounter2: " + baseCounter2);   // 10
        System.out.println("incrementThenAssign: " + incrementThenAssign); // 10
    }
}

Relational Comparisons

Relational operators evaluate the relationship between two operands and always return a boolean outcome (true or false). Do not confuse the assignment operator = with the equality check ==.

Symbol	Description
<	Less than
>	Greater than
<=	Less than or equal to
>=	Greater than or equal to
==	Equality check
!=	Inequality check

public class ComparisonDemo {
    public static void main(String[] args) {
        double threshold = 85.5;
        double examScore = 92.0;

        System.out.println(examScore > threshold); // true
        System.out.println(examScore <= threshold); // false
        System.out.println(examScore == 85.5);     // false
    }
}

Logical Evaluations

Logical operators combine boolean expressions. Both operands must evaluate to a boolean type, and the result is also boolean. Short-circuit variants execute more efficiently by skipping unnecessary evaluations.

Symbol	Type	Description
&	Non-short-circuit AND	Evaluates both sides
|	Non-short-circuit OR	Evaluates both sides
^	XOR	True if exactly one operand is true
!	NOT	Flips the boolean state
&&	Short-circuit AND	Skip right side if left is false
||	Short-circuit OR	Skip right side if left is true

public class LogicFlow {
    public static void main(String[] args) {
        System.out.println(10 > 5 & 8 > 3);       // true
        System.out.println(10 > 5 & 8 < 3);       // false

        int executionCounter = 0;
        
        // Short-circuit AND: condition evaluates to false, so right side is skipped
        boolean scAnd = false && (++executionCounter > 0);
        System.out.println("SC And Counter: " + executionCounter); // 0

        executionCounter = 0;
        // Regular AND: both sides execute regardless of first outcome
        boolean regAnd = false & (++executionCounter > 0);
        System.out.println("Reg And Counter: " + executionCounter); // 1
    }
}

Bitwise Operations

Bitwise operators perform direct manipulation at the binary level, applicable to integer-based types (byte, short, int, long, char).

Symbol	Function
&	Bitwise AND
|	Bitwise OR
~	Bitwise NOT (flips all bits)
^	Bitwise XOR
<<	Left shift
>>	Right shift (preserves sign)
>>>	Unsigned right shift (fills with zeros)

Assignment Mechanics

Assignment operators transfer values from the right-hand expression to the left-hand variable. Compound assignments offer syntactic shorthand but introduce important type-handling behaviors.

• Simple Assignment: = directly maps the RHS value to the LHS target.
• Compound Assignment: Operators like +=, -=, *= combine calculation and assignment. Crucially, x += y automatically performs an implicit cast equivalent to x = (type)(x + y), which prevents compilation errors that would occur with explicit x = x + y.

Warning: Compound assignments do not prevent data loss during narrowing conversions. Precision may still be lost if the computed value exceeds the target variable's range.

public class AssignmentRules {
    public static void main(String[] args) {
        long balance = 1000L;
        balance += 500L; // Equivalent to balance = balance + 500L
        System.out.println("Updated Balance: " + balance); // 1500

        byte clipCount = 120;
        
        // This triggers a compile-time error: possible lossy conversion from int to byte
        // clipCount = clipCount + 10; 
        
        // This compiles successfully due to implicit casting within the compound operator
        clipCount += 10; 
        System.out.println("Clips After Add: " + clipCount); // 130

        byte overflowTest = 100;
        overflowTest += 200; // Results in -156 due to byte range overflow (-128 to 127)
        System.out.println("Overflow Result: " + overflowTest);
    }
}

String Concatenation

The + operator serves dual purposes: numeric addition and text joining. When at least one operand is a String, Java treats the operation as concatenation and returns a String. Without parentheses, evaluation proceeds strictly from left to right.

public class TextBuilding {
    public static void main(String[] args) {
        System.out.println(4 + 5 + " apples"); // "9 apples"
        System.out.println("Apples: " + 4 + 5); // "Apples: 45" (concatenated as text)
        
        int mathGrade = 88;
        int englishGrade = 94;
        
        // Parentheses force numeric addition before string joining
        System.out.println("Average Score: " + ((mathGrade + englishGrade) / 2)); // 91
    }
}

Ternary Expressions

The ternary operator ? : provides a concise alternative to basic if-else blocks. It requires exactly three operands: a condition, a result for truth, and a result for falsehood.

Syntax: condition ? valueIfTrue : valueIfFalse

public class TernaryExample {
    public static void main(String[] args) {
        boolean isPass = false;
        String gradeStatus = isPass ? "Promoted" : "Requires Tutoring";
        System.out.println(gradeStatus); // Requires Tutoring

        int temperatureF = 72;
        String weatherLabel = temperatureF > 80 ? "Hot" : "Comfortable";
        System.out.println(weatherLabel); // Comfortable
    }
}