Java final Keyword—Mutable Reference Trap Data Loss

import java.util.ArrayList;
import java.util.List;

public class FinalVariableDemo {

    // static final = a true compile-time constant shared across all instances
    // Convention: ALL_CAPS with underscores for static final constants
    private static final int MAX_LOGIN_ATTEMPTS = 3;

    // instance final field — must be set in every constructor
    private final String username;

    public FinalVariableDemo(String username) {
        // This is the ONE allowed assignment for this instance field
        this.username = username;
    }

    public void demonstrateFinalBehaviour() {

        // final local variable — assigned once, never changed
        final double taxRate = 0.2;

        double itemPrice = 49.99;
        double taxAmount = itemPrice * taxRate;

        // The line below would cause a compile error: cannot assign a value to final variable taxRate
        // taxRate = 0.25;  <-- COMPILE ERROR if you uncomment this

        System.out.println("Username     : " + username);
        System.out.println("Max attempts : " + MAX_LOGIN_ATTEMPTS);
        System.out.println("Tax rate     : " + taxRate);
        System.out.println("Tax on $" + itemPrice + " = $" + taxAmount);

        // KEY POINT: final reference != immutable object
        // The list reference is locked, but the list contents are NOT locked
        final List<String> sessionTokens = new ArrayList<>();
        sessionTokens.add("token-abc-123");   // perfectly legal — we're modifying the object
        sessionTokens.add("token-xyz-789");   // still legal

        // This WOULD be a compile error — reassigning the reference itself
        // sessionTokens = new ArrayList<>();  <-- COMPILE ERROR

        System.out.println("Session tokens: " + sessionTokens);
    }

    public static void main(String[] args) {
        FinalVariableDemo demo = new FinalVariableDemo("alice");
        demo.demonstrateFinalBehaviour();
    }
}

// Base class — defines a payment workflow
class PaymentProcessor {

    private static final double FRAUD_THRESHOLD = 10_000.00;

    // This method defines steps that MUST happen in this order for every payment.
    // Subclasses can customise HOW they charge, but not WHAT checks surround it.
    public final boolean processPayment(String customerId, double amount) {

        // Step 1: fraud check — no subclass can skip or alter this
        if (!passesFraudCheck(customerId, amount)) {
            System.out.println("[BLOCKED] Fraud check failed for customer: " + customerId);
            return false;
        }

        // Step 2: delegate to subclass-specific charge logic
        boolean charged = chargeCustomer(customerId, amount);

        // Step 3: audit log — no subclass can skip this either
        auditLog(customerId, amount, charged);

        return charged;
    }

    // private fraud check — already hidden from subclasses
    private boolean passesFraudCheck(String customerId, double amount) {
        // Simplified: flag anything over the threshold
        return amount <= FRAUD_THRESHOLD;
    }

    // Subclasses override THIS to provide their own charging mechanism
    protected boolean chargeCustomer(String customerId, double amount) {
        System.out.println("[DEFAULT] Charging $" + amount + " to customer: " + customerId);
        return true;
    }

    private void auditLog(String customerId, double amount, boolean success) {
        System.out.println("[AUDIT] Customer: " + customerId
                + " | Amount: $" + amount
                + " | Success: " + success);
    }
}

// Subclass provides a Stripe-specific charge implementation
class StripePaymentProcessor extends PaymentProcessor {

    @Override
    protected boolean chargeCustomer(String customerId, double amount) {
        System.out.println("[STRIPE] Sending charge request for $" + amount
                + " — customer: " + customerId);
        return true; // simulate a successful Stripe API call
    }

    // The line below would cause a compile error:
    // Cannot override the final method from PaymentProcessor
    //
    // @Override
    // public boolean processPayment(String customerId, double amount) { ... }
}

public class PaymentProcessor {
    public static void main(String[] args) {
        PaymentProcessor stripe = new StripePaymentProcessor();

        System.out.println("--- Transaction 1: Normal amount ---");
        stripe.processPayment("cust-001", 149.99);

        System.out.println();
        System.out.println("--- Transaction 2: Suspicious amount ---");
        stripe.processPayment("cust-002", 15_000.00);
    }
}

// final class — this is an immutable value type.
// Making it final prevents subclasses from adding mutable fields
// or overriding equals/hashCode in ways that break collections.
public final class Money {

    private final String currencyCode;  // e.g. "USD", "EUR"
    private final long   amountInCents; // store as cents to avoid floating-point errors

    public Money(String currencyCode, long amountInCents) {
        if (currencyCode == null || currencyCode.isBlank()) {
            throw new IllegalArgumentException("Currency code must not be blank");
        }
        if (amountInCents < 0) {
            throw new IllegalArgumentException("Amount must not be negative");
        }
        // Both fields are final — assigned here and never changed
        this.currencyCode  = currencyCode.toUpperCase();
        this.amountInCents = amountInCents;
    }

    // Returns a NEW Money object — the original is never mutated
    public Money add(Money other) {
        if (!this.currencyCode.equals(other.currencyCode)) {
            throw new IllegalArgumentException(
                "Cannot add " + this.currencyCode + " and " + other.currencyCode);
        }
        return new Money(this.currencyCode, this.amountInCents + other.amountInCents);
    }

    public String getFormattedAmount() {
        // Divide by 100 to display as decimal dollars/euros/etc.
        return currencyCode + " " + String.format("%.2f", amountInCents / 100.0);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Money)) return false;
        Money other = (Money) obj;
        // Because the class is final, we KNOW obj is exactly Money — not a sneaky subclass
        return this.amountInCents == other.amountInCents
            && this.currencyCode.equals(other.currencyCode);
    }

    @Override
    public int hashCode() {
        return 31 * currencyCode.hashCode() + Long.hashCode(amountInCents);
    }

    @Override
    public String toString() {
        return getFormattedAmount();
    }

    // --- Attempting to extend Money would cause a compile error: ---
    // class TaxedMoney extends Money { }  <-- COMPILE ERROR: cannot inherit from final Money

    public static void main(String[] args) {
        Money productPrice  = new Money("USD", 1999); // $19.99
        Money shippingCost  = new Money("USD",  599); // $5.99
        Money totalCost     = productPrice.add(shippingCost);

        System.out.println("Product price  : " + productPrice);
        System.out.println("Shipping cost  : " + shippingCost);
        System.out.println("Total          : " + totalCost);

        // Prove immutability — productPrice is unchanged after add()
        System.out.println("Original price still: " + productPrice);

        Money anotherTotal = new Money("USD", 2598);
        System.out.println("Equals check   : " + totalCost.equals(anotherTotal));
    }
}

import java.util.List;

public class OrderCalculator {

    // final parameters — the references 'items' and 'discountPercent' cannot be
    // reassigned inside this method. Prevents accidental shadowing in long methods.
    public double calculateTotal(final List<String> items, final double discountPercent) {

        // This would be a compile error:
        // discountPercent = 0.0;  <-- COMPILE ERROR: cannot assign a value to final variable

        double subtotal = items.size() * 9.99; // simplified: each item is $9.99
        double discount = subtotal * (discountPercent / 100.0);
        double total    = subtotal - discount;

        System.out.println("Items ordered  : " + items.size());
        System.out.println("Subtotal       : $" + String.format("%.2f", subtotal));
        System.out.println("Discount (" + discountPercent + "%) : -$" + String.format("%.2f", discount));
        System.out.println("Total          : $" + String.format("%.2f", total));

        return total;
    }

    // Demonstrating 'effectively final' in a lambda capture
    public void printItemsAsync(final List<String> items) {
        // 'items' is final — safe to capture in the lambda below
        Runnable printer = () -> {
            for (String item : items) {
                System.out.println("  - " + item);
            }
        };
        printer.run();
    }

    public static void main(String[] args) {
        OrderCalculator calculator = new OrderCalculator();

        List<String> cart = List.of("Java Book", "Mechanical Keyboard", "USB Hub");

        System.out.println("=== Order Summary ===");
        calculator.calculateTotal(cart, 10.0); // 10% discount

        System.out.println();
        System.out.println("=== Your Items ===");
        calculator.printItemsAsync(cart);
    }
}

import java.util.ArrayList;
import java.util.List;

public class MutableVsImmutable {

    public static void main(String[] args) {
        // Layer 1: final reference, mutable object
        final List<String> names = new ArrayList<>();
        names.add("Alice"); // allowed -- object changes
        // names = new ArrayList<>(); // compile error -- reference locked

        // Layer 2: final reference, immutable object
        final List<String> immutableNames = List.of("Alice", "Bob");
        // immutableNames.add("Charlie"); // throws UnsupportedOperationException

        // Deeply immutable custom class
        final io.thecodeforge.ImmutablePerson person =
            new io.thecodeforge.ImmutablePerson("Alice", 30);
        // person.getAge() always returns 30
        // Cannot change name or age
    }
}

// Truly immutable class
final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name; // String is already immutable
        this.age = age;   // primitive is always immutable
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

// io.thecodeforge
public class OrderService {
    private final ConcurrentHashMap<String, Order> orders;

    public OrderService() {
        this.orders = new ConcurrentHashMap<>();
    }

    public Order getOrder(String id) {
        return orders.get(id);
    }

    public void addOrder(String id, Order order) {
        // Thread-safe mutation
        orders.put(id, order);
    }

    // Immutable view for callers
    public Map<String, Order> getAllOrders() {
        return Collections.unmodifiableMap(orders);
    }
}

// io.thecodeforge
import java.util.List;

public class ConfigDefaults {
    // DANGER: mutable reference exposed globally
    // public static final List<String> DEFAULT_NAMES = new ArrayList<>();

    // SAFE: truly immutable collection
    public static final List<String> DEFAULT_NAMES = List.of("alpha", "beta", "gamma");

    // SAFE with static initializer
    // public static final List<String> DEFAULT_NAMES;
    // static {
    //     List<String> tmp = new ArrayList<>();
    //     tmp.add("alpha");
    //     DEFAULT_NAMES = Collections.unmodifiableList(tmp);
    // }
}