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());
    }
}