Operators #

// ANTI-PATTERN: integer division discards the decimal
int a = 10, b = 3;
double result = a / b;            // 3.0 — not 3.333...!
System.out.println(a / b);       // 3 — the decimal is discarded

double avg = (1 + 2 + 3) / 3;  // 2.0 — not 2.0!
// 1+2+3 = 6, then 6/3 = 2 (integer), only then converted to double

// CORRECT: cast one operand to double first
double result = (double) a / b;          // 3.3333...
double result = a / (double) b;          // 3.3333...
double avg  = (1 + 2 + 3) / 3.0;      // 2.0 — correct
double avg  = (double)(1 + 2 + 3) / 3; // 2.0 — correct

System.out.println( 7 % 3);   //  1
System.out.println(-7 % 3);   // -1 — negative! (not 2)
System.out.println( 7 % -3);  //  1

// If you need a result that's always positive (true modulo):
int result = ((-7) % 3 + 3) % 3; // 2 — always non-negative

int x = 5;

// Post-increment: the old value is used first, THEN incremented
int a = x++;   // a = 5, then x becomes 6
System.out.println(a); // 5
System.out.println(x); // 6

// Pre-increment: incremented first, THEN the new value is used
int b = ++x;   // x becomes 7 first, then b = 7
System.out.println(b); // 7
System.out.println(x); // 7

// ANTI-PATTERN: ++/-- inside complex expressions — hard to read
int y = 5;
int z = y++ + ++y; // confusing: y=5, then 5 + 7 = 12? or?

// CORRECT: use ++/-- as standalone statements
y++;
z = y + y;

byte b = 10;

// This is a COMPILE ERROR — int can't automatically fit into byte
b = b + 1;          // ✗ ERROR: possible lossy conversion from int to byte

// This is CORRECT — += includes an implicit cast
b += 1;             // ✓ equivalent to b = (byte)(b + 1)

// Implication: compound assignment can silently narrow
byte value = 100;
value += 100;        // value = (byte)(100 + 100) = (byte)200 = -56! (overflow)

// && stops at the left operand if the result is already false
String name = null;
if (name != null && name.length() > 0) {  // ✓ safe
    System.out.println(name);
    // if name is null, name.length() is never called
}

// ANTI-PATTERN: no null check on the left
if (name.length() > 0 && name != null) {  // ✗ NullPointerException if name is null!

// || stops at the left operand if the result is already true
int cache = -1;
int value = (cache != -1) || calculateExpensiveValue(); // calculateExpensiveValue() isn't called if cache is valid

// Use && (short-circuit) for normal conditions
// The right operand isn't evaluated if not needed
if (list != null && list.size() > 0) { }

// Use & (non-short-circuit) ONLY if the right operand must always execute
// because it has a needed side effect
if (validateField1() & validateField2()) {
    // both validations always run, error messages from both are collected
}

int a = 0b1010; // 10 in decimal
int b = 0b1100; // 12 in decimal

System.out.println(a & b);   // 0b1000 = 8  (AND)
System.out.println(a | b);   // 0b1110 = 14 (OR)
System.out.println(a ^ b);   // 0b0110 = 6  (XOR)
System.out.println(~a);      // -11          (NOT: flips all bits + sign)

// Shift: faster multiplication/division by powers of 2
int x = 4;
System.out.println(x << 2);  // 16  (x * 4)
System.out.println(x >> 1);  // 2   (x / 2)

// Bitmask — store many flags in a single int
final int FLAG_READ   = 0b001; // 1
final int FLAG_WRITE  = 0b010; // 2
final int FLAG_EXECUTE = 0b100; // 4

int permission = FLAG_READ | FLAG_WRITE; // permission = 0b011 = 3

// Check whether a specific flag is active
boolean canRead  = (permission & FLAG_READ)    != 0; // true
boolean canExec = (permission & FLAG_EXECUTE) != 0; // false

// Add a flag
permission |= FLAG_EXECUTE;   // permission = 0b111 = 7

// Remove a flag
permission &= ~FLAG_WRITE;     // permission = 0b101 = 5

// Syntax: condition ? valueIfTrue : valueIfFalse
int max = (a > b) ? a : b;

String status = (age >= 18) ? "adult" : "minor";

// Useful for default values
String name = (input != null) ? input : "Anonymous";

// Or use its cleaner equivalent:
String name = Objects.requireNonNullElse(input, "Anonymous");

// CORRECT: ternary for simple one-line expressions
int abs = (x >= 0) ? x : -x;
String label = active ? "Active" : "Inactive";

// ANTI-PATTERN: nested ternary — very hard to read
String grade = (score >= 90) ? "A"
                : (score >= 80) ? "B"
                : (score >= 70) ? "C"
                : (score >= 60) ? "D" : "E"; // ✗ use if-else or switch

// CORRECT: if-else for complex or nested logic
String grade;
if      (score >= 90) grade = "A";
else if (score >= 80) grade = "B";
else if (score >= 70) grade = "C";
else if (score >= 60) grade = "D";
else                  grade = "E";

// Old way — check then cast separately
Object obj = "Hello Java";
if (obj instanceof String) {
    String s = (String) obj;  // manual cast
    System.out.println(s.length());
}

// New way (Java 16+) — pattern matching: check + bind at once
if (obj instanceof String s) {  // s is automatically a String inside this block
    System.out.println(s.length()); // no manual cast needed
}

// Pattern matching makes code far more concise for polymorphism
void process(Object shape) {
    if (shape instanceof Circle c) {
        System.out.println("Radius: " + c.getRadius());
    } else if (shape instanceof Square p) {
        System.out.println("Side: " + p.getSide());
    } else if (shape instanceof Triangle s) {
        System.out.println("Base: " + s.getBase());
    }
}

// instanceof is always false for null
String s = null;
System.out.println(s instanceof String); // false — doesn't throw NPE

// Precedence examples in practice
int result = 2 + 3 * 4;       // 14 — not 20: * has higher precedence than +
int result = (2 + 3) * 4;     // 20 — parentheses force the order

boolean check = 5 > 3 && 2 < 4; // true: > and < are evaluated first, then &&

// ANTI-PATTERN: relying on precedence for complex expressions
int x = a++ * b-- + c >> 2;  // ✗ very hard to read

// CORRECT: use parentheses to clarify the intended order
int x = ((a++) * (b--) + c) >> 2; // ✓ the intent is clear