OOP essentials

/** Encapsulation: the balance can only change through methods that enforce the rules. */
class Account {
  #balance: number; // truly private: no one outside can set it
  constructor(readonly owner: string, balance = 0) { this.#balance = balance; }
  get balance(): number { return this.#balance; }
  withdraw(amount: number): void {
    if (amount <= 0) throw new Error("amount must be positive");
    if (amount > this.#balance) throw new Error("insufficient funds");
    this.#balance -= amount;
  }
}

/** Abstraction: callers know "it can pay", not how. */
interface PaymentMethod { pay(amount: number): string; }

class CardPayment implements PaymentMethod {
  constructor(private last4: string) {}
  pay(amount: number): string { return `charged ${amount} to card ending ${this.last4}`; }
}

class WalletPayment implements PaymentMethod {
  constructor(private account: Account) {} // composition: a wallet HAS an account; it isn't one
  pay(amount: number): string {
    this.account.withdraw(amount);
    return `paid ${amount} from ${this.account.owner}'s wallet, ${this.account.balance} left`;
  }
}

interface LineItem { sku: string; price: number; qty: number; }

/** Composition: line items live and die with their order. */
class Order {
  private items: LineItem[] = [];
  add(sku: string, price: number, qty = 1): Order {
    this.items.push({ sku, price, qty });
    return this;
  }
  total(): number { return this.items.reduce((s, i) => s + i.price * i.qty, 0); }
  checkout(method: PaymentMethod): string { return method.pay(this.total()); } // polymorphism: works for any PaymentMethod
}

const order = new Order().add("book", 30).add("pen", 5, 2);
console.log("total:", order.total());
const wallet = new Account("ana", 100);
for (const method of [new CardPayment("4242"), new WalletPayment(wallet)]) console.log(order.checkout(method));
try {
  new WalletPayment(wallet).pay(500);
} catch (e) {
  console.log("wallet:", (e as Error).message);
}

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

/** Encapsulation: the balance can only change through methods that enforce the rules. */
class Account {
    final String owner;
    private int balance; // private: no one outside can set it

    Account(String owner, int balance) {
        this.owner = owner;
        this.balance = balance;
    }

    int balance() {
        return balance;
    }

    synchronized void withdraw(int amount) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
        if (amount > balance) throw new IllegalArgumentException("insufficient funds");
        balance -= amount;
    }
}

/** Abstraction: callers know "it can pay", not how. */
interface PaymentMethod {
    String pay(int amount);
}

class CardPayment implements PaymentMethod {
    private final String last4;

    CardPayment(String last4) {
        this.last4 = last4;
    }

    public String pay(int amount) {
        return "charged " + amount + " to card ending " + last4;
    }
}

class WalletPayment implements PaymentMethod {
    private final Account account; // composition: a wallet HAS an account; it isn't one

    WalletPayment(Account account) {
        this.account = account;
    }

    public String pay(int amount) {
        account.withdraw(amount);
        return "paid " + amount + " from " + account.owner + "'s wallet, " + account.balance() + " left";
    }
}

record LineItem(String sku, int price, int qty) {}

/** Composition: line items live and die with their order. */
class Order {
    private final List<LineItem> items = new ArrayList<>();

    Order add(String sku, int price, int qty) {
        items.add(new LineItem(sku, price, qty));
        return this;
    }

    int total() {
        return items.stream().mapToInt(i -> i.price() * i.qty()).sum();
    }

    String checkout(PaymentMethod method) {
        return method.pay(total()); // polymorphism: works for any PaymentMethod
    }
}

public class Main {
    public static void main(String[] args) {
        Order order = new Order().add("book", 30, 1).add("pen", 5, 2);
        System.out.println("total: " + order.total());
        Account wallet = new Account("ana", 100);
        for (PaymentMethod m : List.of(new CardPayment("4242"), new WalletPayment(wallet))) System.out.println(order.checkout(m));
        try {
            new WalletPayment(wallet).pay(500);
        } catch (IllegalArgumentException e) {
            System.out.println("wallet: " + e.getMessage());
        }
    }
}