Java Operators: Integer Division Bug Costs £5,000

public class ArithmeticOperatorsDemo {
    public static void main(String[] args) {

        int totalPrice = 250;       // starting price in pence
        int discountAmount = 30;    // discount to apply
        int numberOfItems = 3;      // items in the basket

        // Basic arithmetic — works exactly like a calculator
        int priceAfterDiscount = totalPrice - discountAmount;
        System.out.println("Price after discount: " + priceAfterDiscount); // 220

        int totalForAllItems = priceAfterDiscount * numberOfItems;
        System.out.println("Total for all items: " + totalForAllItems); // 660

        // Integer division — IMPORTANT: both values are int, so result is also int
        // Any decimal part is simply dropped (not rounded)
        int sharePerPerson = totalForAllItems / 2;
        System.out.println("Each person pays: " + sharePerPerson); // 330

        // Modulus — gives us the REMAINDER after division
        // Great for checking even/odd, or wrapping values
        int leftoverPence = totalForAllItems % 7;
        System.out.println("Remainder when split 7 ways: " + leftoverPence); // 2

        // Checking if a number is even — a classic modulus use case
        int quantity = 8;
        if (quantity % 2 == 0) {
            System.out.println(quantity + " is an even number"); // prints this
        }

        // Increment — adds 1 to the variable, shorter than writing score = score + 1
        int score = 10;
        score++; // score is now 11
        System.out.println("Score after increment: " + score); // 11

        // Decrement — subtracts 1
        int livesRemaining = 3;
        livesRemaining--; // livesRemaining is now 2
        System.out.println("Lives remaining: " + livesRemaining); // 2
    }
}

public class RelationalAndLogicalDemo {
    public static void main(String[] args) {

        int userAge = 20;
        boolean hasValidMembership = true;
        double accountBalance = 150.75;
        double minimumRequired = 100.00;

        // --- RELATIONAL OPERATORS ---
        // Each comparison produces a boolean: true or false

        boolean isAdult = userAge >= 18;
        System.out.println("Is user an adult? " + isAdult); // true

        boolean balanceIsSufficient = accountBalance > minimumRequired;
        System.out.println("Balance sufficient? " + balanceIsSufficient); // true

        boolean isExactlyTwenty = userAge == 20;
        System.out.println("Is user exactly 20? " + isExactlyTwenty); // true

        boolean isNotTwenty = userAge != 20;
        System.out.println("Is user NOT 20? " + isNotTwenty); // false

        // --- LOGICAL OPERATORS ---

        // && (AND) — BOTH sides must be true for the result to be true
        // Real use: user can access premium content only if adult AND has membership
        boolean canAccessPremiumContent = isAdult && hasValidMembership;
        System.out.println("Can access premium content? " + canAccessPremiumContent); // true

        // || (OR) — AT LEAST ONE side must be true
        // Real use: show warning if balance is low OR membership has expired
        boolean membershipExpired = false;
        boolean showWarning = !balanceIsSufficient || membershipExpired;
        System.out.println("Show account warning? " + showWarning); // false

        // ! (NOT) — flips the boolean value
        boolean isLoggedOut = !hasValidMembership; // hasValidMembership is true, so this is false
        System.out.println("Is user logged out? " + isLoggedOut); // false

        // Combining everything — a realistic access check
        if (isAdult && hasValidMembership && balanceIsSufficient) {
            System.out.println("Access granted — welcome to the platform!");
        } else {
            System.out.println("Access denied — check your account.");
        }
    }
}

public class AssignmentOperatorsDemo {
    public static void main(String[] args) {

        int playerScore = 100; // basic assignment — storing 100 into playerScore

        // Compound assignment operators — shorthand for common operations

        playerScore += 50; // same as: playerScore = playerScore + 50
        System.out.println("After bonus points: " + playerScore); // 150

        playerScore -= 20; // same as: playerScore = playerScore - 20
        System.out.println("After penalty: " + playerScore); // 130

        playerScore *= 2; // same as: playerScore = playerScore * 2 (double multiplier active)
        System.out.println("After double multiplier: " + playerScore); // 260

        playerScore /= 4; // same as: playerScore = playerScore / 4
        System.out.println("After score divided: " + playerScore); // 65

        playerScore %= 10; // same as: playerScore = playerScore % 10 (keep only the ones digit)
        System.out.println("Remainder kept: " + playerScore); // 5

        // --- TERNARY OPERATOR ---
        // Structure: condition ? valueIfTrue : valueIfFalse
        // Think of it as a one-line if-else for simple value decisions

        int temperature = 28;

        // Standard if-else version (verbose):
        // String advice;
        // if (temperature > 25) { advice = "wear sunscreen"; }
        // else { advice = "bring a jacket"; }

        // Ternary version (clean and concise):
        String weatherAdvice = (temperature > 25) ? "wear sunscreen" : "bring a jacket";
        System.out.println("Weather advice: " + weatherAdvice); // wear sunscreen

        // Another real-world example — labelling a value
        int cartItemCount = 1;
        String itemLabel = (cartItemCount == 1) ? "item" : "items";
        System.out.println("You have " + cartItemCount + " " + itemLabel + " in your cart.");
        // Output: You have 1 item in your cart.
    }
}

public class OperatorPrecedenceDemo {
    public static void main(String[] args) {

        // --- WITHOUT PARENTHESES — precedence decides the order ---

        // Multiplication happens BEFORE addition, just like in maths
        int resultWithoutBrackets = 2 + 3 * 4;
        // Java calculates: 2 + (3 * 4) = 2 + 12 = 14
        System.out.println("Without brackets: " + resultWithoutBrackets); // 14

        // --- WITH PARENTHESES — you control the order ---
        int resultWithBrackets = (2 + 3) * 4;
        // Java calculates: (5) * 4 = 20
        System.out.println("With brackets: " + resultWithBrackets); // 20

        // Real-world example: calculating a discount correctly
        double originalPrice = 200.0;
        double discountPercent = 10.0;
        double shippingCost = 15.0;

        // WRONG — precedence causes a bug here:
        // Java calculates: 200.0 - (10.0 / 100.0 * 200.0) + 15.0
        // That's actually correct here, but watch what happens when intent is ambiguous

        // CLEAR — parentheses show exactly what you intend:
        double discountAmount = (discountPercent / 100.0) * originalPrice; // 20.0
        double finalPrice = originalPrice - discountAmount + shippingCost;
        System.out.println("Discount amount: £" + discountAmount);  // £20.0
        System.out.println("Final price: £" + finalPrice);          // £195.0

        // --- RELATIONAL before LOGICAL in precedence ---
        int userAge = 22;
        double userBalance = 80.0;

        // This works correctly because > and < are evaluated BEFORE &&
        // So Java reads it as: (userAge > 18) && (userBalance > 50.0)
        boolean isEligible = userAge > 18 && userBalance > 50.0;
        System.out.println("User is eligible: " + isEligible); // true

        // Pre-increment vs post-increment — a precedence-related gotcha
        int counter = 5;

        int postIncrementResult = counter++;  // counter's CURRENT value (5) is assigned, THEN counter becomes 6
        System.out.println("Post-increment result: " + postIncrementResult); // 5
        System.out.println("Counter after post-increment: " + counter);       // 6

        int preIncrementResult = ++counter;   // counter becomes 7 FIRST, then 7 is assigned
        System.out.println("Pre-increment result: " + preIncrementResult);  // 7
        System.out.println("Counter after pre-increment: " + counter);       // 7
    }
}

public class BitwiseOperatorsDemo {
    public static void main(String[] args) {

        // --- Define permission flags as powers of 2 ---
        final int READ = 1 << 0;  // 0001 = 1
        final int WRITE = 1 << 1; // 0010 = 2
        final int EXECUTE = 1 << 2; // 0100 = 4

        // Combine permissions using bitwise OR
        int userPermissions = READ | WRITE; // 0011 = 3
        System.out.println("User permissions: " + userPermissions); // 3

        // Check if user has READ permission using bitwise AND
        boolean canRead = (userPermissions & READ) != 0;
        System.out.println("Can read? " + canRead); // true

        // Check if user has EXECUTE permission
        boolean canExecute = (userPermissions & EXECUTE) != 0;
        System.out.println("Can execute? " + canExecute); // false

        // Add EXECUTE permission using OR
        userPermissions |= EXECUTE; // 0111 = 7
        System.out.println("Updated permissions: " + userPermissions); // 7

        // Remove WRITE permission using AND with complement
        userPermissions &= ~WRITE; // 0101 = 5
        System.out.println("After removing WRITE: " + userPermissions); // 5

        // XOR toggles a flag
        userPermissions ^= EXECUTE; // 0001 = 1 (EXECUTE removed)
        System.out.println("After toggling EXECUTE: " + userPermissions); // 1

        // --- Bit shifts ---
        int value = 8;  // 1000
        System.out.println("value << 1: " + (value << 1)); // 16 (10000)
        System.out.println("value >> 1: " + (value >> 1)); // 4 (0100)

        int negative = -8; // 11111111 11111111 11111111 11111000
        System.out.println("negative >> 1: " + (negative >> 1));  // -4 (preserves sign bit)
        System.out.println("negative >>> 1: " + (negative >>> 1)); // 2147483644 (fills with 0)
    }
}

// io.thecodeforge
import java.math.BigDecimal;

public class DiscountCalculator {
    public BigDecimal applyDiscount(Order order) {
        // Good: single ternary, no side effects
        BigDecimal rate = order.isPremium() ? new BigDecimal("0.20") : new BigDecimal("0.05");
        
        // Bad: nested ternary — don't do this
        // BigDecimal result = order.isPremium() ? order.getValue().multiply(new BigDecimal("0.80")) : order.isVeteran() ? order.getValue().multiply(new BigDecimal("0.85")) : order.getValue();
        
        return order.getValue().multiply(BigDecimal.ONE.subtract(rate));
    }
}

// io.thecodeforge
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class EventRouter {
    @EventListener
    public void handleDomainEvent(Object event) {
        // Java 16+ pattern matching: no explicit cast
        if (event instanceof OrderCreated oc) {
            oc.getOrderId(); // oc is already cast
        } else if (event instanceof PaymentFailed pf) {
            alertFraudTeam(pf.getUserId());
        } else {
            log.warn("Unhandled event type: {}", event.getClass().getSimpleName());
        }
    }
    
    private void alertFraudTeam(String userId) {
        // relevant code
    }
}