Encapsulation — Data Hiding Done Right

# BAD: No encapsulation — everything is public
class BankAccountUnsafe:
    def __init__(self, owner: str, balance: float):
        self.owner = owner
        self.balance = balance

    def withdraw(self, amount: float) -> None:
        if amount > self.balance:
            print("Insufficient funds!")
            return
        self.balance -= amount


account = BankAccountUnsafe("Alice", 1000.0)

# Anyone can bypass the withdraw method and break the rules:
account.balance = -99999      # No validation!
account.owner = ""             # Empty owner? Sure!
account.balance = "not money"  # A string? Why not!

print(account.balance)  # 'not money' — disaster

# The withdraw method has validation, but it's useless
# because anyone can just modify balance directly.

class BankAccount:
    """A properly encapsulated bank account.
    
    All attributes are private (double underscore).
    All access goes through methods with validation.
    """

    def __init__(self, owner: str, balance: float = 0.0):
        if not owner.strip():
            raise ValueError("Owner name cannot be empty")
        if balance < 0:
            raise ValueError("Initial balance cannot be negative")

        self.__owner = owner.strip()     # Private!
        self.__balance = balance          # Private!
        self.__is_frozen = False          # Private!

    # --- Getters: read-only access to private data ---

    @property
    def owner(self) -> str:
        """Read-only access to owner name."""
        return self.__owner

    @property
    def balance(self) -> float:
        """Read-only access to balance."""
        return self.__balance

    @property
    def is_frozen(self) -> bool:
        """Read-only access to frozen status."""
        return self.__is_frozen

    # --- Controlled operations: the ONLY way to change state ---

    def deposit(self, amount: float) -> None:
        """Add money to the account with validation."""
        if self.__is_frozen:
            raise RuntimeError("Cannot deposit into a frozen account")
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.__balance += amount
        print(f"Deposited ${amount:.2f}. New balance: ${self.__balance:.2f}")

    def withdraw(self, amount: float) -> None:
        """Remove money from the account with validation."""
        if self.__is_frozen:
            raise RuntimeError("Cannot withdraw from a frozen account")
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self.__balance:
            raise ValueError(
                f"Insufficient funds: ${amount:.2f} > ${self.__balance:.2f}"
            )
        self.__balance -= amount
        print(f"Withdrew ${amount:.2f}. New balance: ${self.__balance:.2f}")

    def freeze(self) -> None:
        """Freeze the account — no deposits or withdrawals allowed."""
        self.__is_frozen = True
        print(f"Account for {self.__owner} is now FROZEN.")


# --- Usage ---
account = BankAccount("Alice", 1000.0)

# Read data through properties (getters)
print(f"Owner: {account.owner}")      # Alice
print(f"Balance: ${account.balance}")  # $1000.0

# Modify through controlled methods
account.deposit(500.0)    # Deposited $500.00. New balance: $1500.00
account.withdraw(200.0)   # Withdrew $200.00. New balance: $1300.00

# Try to break the rules — all blocked:
try:
    account.balance = -5000  # AttributeError: property has no setter
except AttributeError as e:
    print(f"Blocked: {e}")

try:
    account.withdraw(-100)   # ValueError: must be positive
except ValueError as e:
    print(f"Blocked: {e}")

try:
    account.withdraw(99999)  # ValueError: insufficient funds
except ValueError as e:
    print(f"Blocked: {e}")

# Freeze the account
account.freeze()
try:
    account.deposit(100)     # RuntimeError: cannot deposit into frozen
except RuntimeError as e:
    print(f"Blocked: {e}")

public class BankAccount {
    // All fields are private — no direct access from outside
    private String owner;
    private double balance;
    private boolean isFrozen;

    public BankAccount(String owner, double balance) {
        if (owner == null || owner.trim().isEmpty()) {
            throw new IllegalArgumentException("Owner name cannot be empty");
        }
        if (balance < 0) {
            throw new IllegalArgumentException("Initial balance cannot be negative");
        }
        this.owner = owner.trim();
        this.balance = balance;
        this.isFrozen = false;
    }

    // --- Getters: read-only access ---
    public String getOwner() {
        return owner;
    }

    public double getBalance() {
        return balance;
    }

    public boolean isFrozen() {
        return isFrozen;
    }

    // --- Controlled operations ---
    public void deposit(double amount) {
        if (isFrozen) {
            throw new RuntimeException("Cannot deposit into a frozen account");
        }
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive");
        }
        balance += amount;
        System.out.printf("Deposited $%.2f. New balance: $%.2f%n", amount, balance);
    }

    public void withdraw(double amount) {
        if (isFrozen) {
            throw new RuntimeException("Cannot withdraw from a frozen account");
        }
        if (amount <= 0) {
            throw new IllegalArgumentException("Withdrawal amount must be positive");
        }
        if (amount > balance) {
            throw new IllegalArgumentException(
                    String.format("Insufficient funds: $%.2f > $%.2f", amount, balance));
        }
        balance -= amount;
        System.out.printf("Withdrew $%.2f. New balance: $%.2f%n", amount, balance);
    }

    public void freeze() {
        isFrozen = true;
        System.out.println("Account for " + owner + " is now FROZEN.");
    }

    // Note: No setBalance(), no setOwner() — these can ONLY
    // be changed through deposit() and withdraw().

    public static void main(String[] args) {
        BankAccount account = new BankAccount("Alice", 1000.0);

        System.out.println("Owner: " + account.getOwner());
        System.out.printf("Balance: $%.2f%n", account.getBalance());

        account.deposit(500.0);
        account.withdraw(200.0);

        // account.balance = -5000; // COMPILE ERROR: balance is private

        try {
            account.withdraw(-100);
        } catch (IllegalArgumentException e) {
            System.out.println("Blocked: " + e.getMessage());
        }

        account.freeze();
        try {
            account.deposit(100);
        } catch (RuntimeException e) {
            System.out.println("Blocked: " + e.getMessage());
        }
    }
}