Encapsulation in Java Explained — Why It Matters and How to Use It Right

// ❌ BAD EXAMPLE — This is what NOT to do
// All fields are public, meaning ANY class can modify them directly
public class BrokenBankAccount {

    public String ownerName;   // Anyone can set this to null or empty
    public double balance;     // Anyone can set this to a negative value
    public String accountId;   // Anyone can change the account ID mid-session

    public BrokenBankAccount(String ownerName, double initialDeposit, String accountId) {
        this.ownerName = ownerName;
        this.balance = initialDeposit;
        this.accountId = accountId;
    }
}

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

        BrokenBankAccount account = new BrokenBankAccount("Alice", 1000.00, "ACC-001");

        // This compiles. This runs. This is terrifying.
        account.balance = -999999;   // No check. No log. No error.
        account.ownerName = "";      // Now the account has no owner
        account.accountId = null;    // The account ID is gone

        System.out.println("Owner  : " + account.ownerName);   // prints empty string
        System.out.println("Balance: " + account.balance);     // prints -999999.0
        System.out.println("ID     : " + account.accountId);   // prints null
    }
}

// ✅ GOOD EXAMPLE — Properly encapsulated BankAccount
public class BankAccount {

    // private means ONLY this class can directly read or write these fields
    private final String accountId;   // final + no setter = truly immutable
    private String ownerName;
    private double balance;

    // Constructor enforces valid initial state before the object even exists
    public BankAccount(String accountId, String ownerName, double initialDeposit) {
        if (accountId == null || accountId.isBlank()) {
            throw new IllegalArgumentException("Account ID cannot be null or empty");
        }
        if (ownerName == null || ownerName.isBlank()) {
            throw new IllegalArgumentException("Owner name cannot be null or empty");
        }
        if (initialDeposit < 0) {
            throw new IllegalArgumentException("Initial deposit cannot be negative");
        }
        this.accountId = accountId;
        this.ownerName = ownerName;
        this.balance = initialDeposit;
    }

    // --- GETTERS — read-only access to private state ---

    public String getAccountId() {
        return accountId;   // accountId is readable but never writable from outside
    }

    public String getOwnerName() {
        return ownerName;
    }

    public double getBalance() {
        return balance;
    }

    // --- SETTERS — controlled write access with validation ---

    public void setOwnerName(String newOwnerName) {
        if (newOwnerName == null || newOwnerName.isBlank()) {
            throw new IllegalArgumentException("Owner name cannot be null or empty");
        }
        this.ownerName = newOwnerName;   // Only set if validation passes
    }

    // Note: no setBalance() — balance must only change through controlled operations

    // --- BEHAVIOUR METHODS — the real power of encapsulation ---

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive, got: " + amount);
        }
        this.balance += amount;   // The object controls how balance changes
        System.out.println("Deposited $" + amount + " — New balance: $" + this.balance);
    }

    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Withdrawal amount must be positive");
        }
        if (amount > this.balance) {
            throw new IllegalStateException(
                "Insufficient funds. Requested: $" + amount + ", Available: $" + this.balance
            );
        }
        this.balance -= amount;   // Only reaches here if all rules pass
        System.out.println("Withdrew $" + amount + " — New balance: $" + this.balance);
    }

    @Override
    public String toString() {
        return String.format("BankAccount[id=%s, owner=%s, balance=$%.2f]",
                accountId, ownerName, balance);
    }
}

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

        BankAccount aliceAccount = new BankAccount("ACC-001", "Alice", 1000.00);
        System.out.println("Created: " + aliceAccount);

        aliceAccount.deposit(500.00);
        aliceAccount.withdraw(200.00);

        System.out.println("Final state: " + aliceAccount);

        // Try to break the rules — the object defends itself
        try {
            aliceAccount.withdraw(9999.00);   // More than the balance
        } catch (IllegalStateException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        try {
            aliceAccount.deposit(-100);   // Negative deposit attempt
        } catch (IllegalArgumentException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

// Demonstrating INTENTIONAL encapsulation decisions — not just auto-generated getters/setters
public class UserProfile {

    private final String userId;          // Identity — read-only, set once at creation
    private String displayName;           // Can be updated — needs validation
    private String emailAddress;          // Can be updated — needs format validation
    private int loginAttemptCount;        // Internal counter — NO getter, NO setter exposed
    private boolean accountLocked;        // State — readable but only lockable through behaviour

    public UserProfile(String userId, String displayName, String emailAddress) {
        if (userId == null || userId.isBlank()) {
            throw new IllegalArgumentException("User ID is required");
        }
        this.userId = userId;
        setDisplayName(displayName);    // Reuse setter validation even in constructor
        setEmailAddress(emailAddress);
        this.loginAttemptCount = 0;
        this.accountLocked = false;
    }

    // --- READ-ONLY fields: getter only ---
    public String getUserId() { return userId; }

    // --- Readable and writable with rules ---
    public String getDisplayName() { return displayName; }

    public void setDisplayName(String displayName) {
        if (displayName == null || displayName.isBlank()) {
            throw new IllegalArgumentException("Display name cannot be blank");
        }
        if (displayName.length() > 50) {
            throw new IllegalArgumentException("Display name cannot exceed 50 characters");
        }
        this.displayName = displayName.trim();   // Clean the input before storing
    }

    public String getEmailAddress() { return emailAddress; }

    public void setEmailAddress(String emailAddress) {
        if (emailAddress == null || !emailAddress.contains("@")) {
            throw new IllegalArgumentException("Invalid email address: " + emailAddress);
        }
        this.emailAddress = emailAddress.toLowerCase();   // Normalise before storing
    }

    // --- Account lock state — readable but only changeable through behaviour methods ---
    public boolean isAccountLocked() { return accountLocked; }

    // loginAttemptCount is NEVER exposed directly — it's an internal implementation detail
    public void recordFailedLogin() {
        this.loginAttemptCount++;   // Increment the hidden counter
        System.out.println("Failed login attempt #" + this.loginAttemptCount + " for " + displayName);

        if (this.loginAttemptCount >= 3) {
            this.accountLocked = true;   // Object locks itself based on its own rules
            System.out.println("Account LOCKED for user: " + displayName);
        }
    }

    public void resetLoginAttempts(String adminCode) {
        if (!"ADMIN-RESET".equals(adminCode)) {   // Even resets require authorisation
            throw new SecurityException("Invalid admin code — cannot reset login attempts");
        }
        this.loginAttemptCount = 0;
        this.accountLocked = false;
        System.out.println("Login attempts reset for: " + displayName);
    }

    @Override
    public String toString() {
        return String.format("UserProfile[id=%s, name=%s, email=%s, locked=%b]",
                userId, displayName, emailAddress, accountLocked);
    }

    public static void main(String[] args) {
        UserProfile user = new UserProfile("USR-42", "  Bob Smith  ", "BOB@EXAMPLE.COM");
        System.out.println("Created: " + user);   // Note: name trimmed, email lowercased

        // Simulate three failed logins
        user.recordFailedLogin();
        user.recordFailedLogin();
        user.recordFailedLogin();

        System.out.println("Account locked? " + user.isAccountLocked());

        // loginAttemptCount is private — this line would NOT compile:
        // System.out.println(user.loginAttemptCount);  // ❌ compile error

        user.resetLoginAttempts("ADMIN-RESET");
        System.out.println("After reset — locked? " + user.isAccountLocked());
    }
}

// Immutable class — encapsulation baked into the design
import java.util.Collections;
import java.util.List;

public final class ImmutableOrder {

    private final String orderId;
    private final double totalAmount;
    private final List<String> items;   // mutable type, must be defensively copied

    public ImmutableOrder(String orderId, double totalAmount, List<String> items) {
        if (orderId == null || orderId.isBlank()) throw new IllegalArgumentException();
        if (totalAmount < 0) throw new IllegalArgumentException();
        if (items == null || items.isEmpty()) throw new IllegalArgumentException();

        this.orderId = orderId;
        this.totalAmount = totalAmount;
        // Defensive copy: the caller's list can change, but our copy stays unchanged
        this.items = List.copyOf(items);   // Java 10+ — creates an unmodifiable copy
    }

    // Only getters — no setters at all
    public String getOrderId() { return orderId; }
    public double getTotalAmount() { return totalAmount; }

    // Return an unmodifiable view — caller cannot modify internal list via reference
    public List<String> getItems() {
        return items;   // items is already unmodifiable from List.copyOf()
    }

    @Override
    public String toString() {
        return String.format("Order[id=%s, total=%.2f, items=%s]", orderId, totalAmount, items);
    }

    // Usage
    public static void main(String[] args) {
        List<String> originalItems = new ArrayList<>();
        originalItems.add("Widget");
        originalItems.add("Gadget");

        ImmutableOrder order = new ImmutableOrder("ORD-001", 49.99, originalItems);

        // The caller modifies the original list — the order's internal list is safe
        originalItems.add("FraudItem");

        System.out.println("Order items: " + order.getItems());  // Prints: [Widget, Gadget]

        // Attempt to modify through getter — compile error if using List.of() or ClassCastException
        // order.getItems().add("Another");  // UnsupportedOperationException at runtime
    }
}

// Parent class that enforces encapsulation even for subclasses
public abstract class Account {

    private final String accountId;
    private double balance;

    protected Account(String accountId, double initialBalance) {
        this.accountId = accountId;
        this.balance = initialBalance;
    }

    public final String getAccountId() { return accountId; }
    public final double getBalance() { return balance; }

    // Protected method for subclasses to safely modify balance
    protected final void applyTransaction(double delta) {
        if (Double.isNaN(delta) || Double.isInfinite(delta)) {
            throw new IllegalArgumentException("Invalid delta");
        }
        if (delta < 0 && Math.abs(delta) > balance) {
            throw new IllegalStateException("Insufficient funds");
        }
        this.balance += delta;
    }

    // Template method pattern — subclass can't modify balance directly
    public abstract void processMonthlyFee();
}

public class SavingsAccount extends Account {

    public SavingsAccount(String id, double balance) {
        super(id, balance);
    }

    @Override
    public void processMonthlyFee() {
        // Safe: calls the protected method that validates
        applyTransaction(-5.00);  // Monthly fee of $5
    }

    // Cannot override applyTransaction — it's final
}

// What NOT to do:
// public class CheckingAccount extends Account {
//    public void deductFee() {
//        this.balance -= 10;   // ❌ Compile error: balance is private
//    }
// }