OOP Basics: Classes, Objects and the Four Pillars

package main

import (
	"errors"
	"fmt"
)

// Money is a value object: no identity, never changes, equal when the amounts are equal.
type Money struct{ paisa int64 }

func Taka(t int64) Money               { return Money{t * 100} }
func (m Money) Add(o Money) Money      { return Money{m.paisa + o.paisa} }
func (m Money) Sub(o Money) Money      { return Money{m.paisa - o.paisa} }
func (m Money) Less(o Money) bool      { return m.paisa < o.paisa }
func (m Money) Percent(bp int64) Money { return Money{m.paisa * bp / 10000} } // bp = basis points
func (m Money) String() string         { return fmt.Sprintf("%d.%02d tk", m.paisa/100, m.paisa%100) }

var ErrInsufficient = errors.New("insufficient balance")

// Wallet is an entity: it has an ID and its balance changes over time.
// Encapsulation: balance is private, so the only way to change it is a method that checks the rules.
type Wallet struct {
	ID      string
	balance Money
}

func (w *Wallet) Deposit(m Money) { w.balance = w.balance.Add(m) }
func (w *Wallet) Balance() Money  { return w.balance }

func (w *Wallet) Withdraw(m Money) error {
	if w.balance.Less(m) {
		return ErrInsufficient
	}
	w.balance = w.balance.Sub(m)
	return nil
}

// Abstraction: checkout only knows "something that can pay". It never asks which kind.
type PaymentMethod interface {
	Name() string
	Pay(amount Money) (fee Money, err error)
}

type Card struct{}

func (Card) Name() string               { return "card" }
func (Card) Pay(a Money) (Money, error) { return a.Percent(150), nil } // 1.5%

type Bkash struct{ wallet *Wallet }

func (Bkash) Name() string { return "bkash" }
func (b Bkash) Pay(a Money) (Money, error) {
	fee := a.Percent(185) // 1.85%
	if err := b.wallet.Withdraw(a.Add(fee)); err != nil {
		return Money{}, err
	}
	return fee, nil
}

type Cash struct{}

func (Cash) Name() string             { return "cash" }
func (Cash) Pay(Money) (Money, error) { return Money{}, nil }

// Polymorphism: one call, and each payment method does its own thing.
func checkout(pm PaymentMethod, amount Money) {
	fee, err := pm.Pay(amount)
	if err != nil {
		fmt.Printf("%-6s pays %s: %v\n", pm.Name(), amount, err)
		return
	}
	fmt.Printf("%-6s pays %s, fee %s\n", pm.Name(), amount, fee)
}

func main() {
	w := &Wallet{ID: "W-1"}
	w.Deposit(Taka(500))
	fmt.Printf("wallet %s balance %s\n", w.ID, w.Balance())

	checkout(Card{}, Taka(1200))
	checkout(Bkash{w}, Taka(300))
	fmt.Printf("wallet %s balance %s\n", w.ID, w.Balance())
	checkout(Bkash{w}, Taka(300))
	checkout(Cash{}, Taka(80))

	fmt.Println("Taka(5) == Taka(5):", Taka(5) == Taka(5))
	// Entities are the same when their IDs match, even if other fields differ.
	loaded := &Wallet{ID: "W-1"} // e.g. the same wallet loaded again from the database
	fmt.Println("same wallet (by ID):", w.ID == loaded.ID)
}

from __future__ import annotations

from dataclasses import dataclass
from typing import Protocol


@dataclass(frozen=True)
class Money:
    """A value object: no identity, never changes, equal when the amounts are equal."""
    paisa: int

    @staticmethod
    def taka(t: int) -> Money:
        return Money(t * 100)

    def add(self, o: Money) -> Money:
        return Money(self.paisa + o.paisa)

    def sub(self, o: Money) -> Money:
        return Money(self.paisa - o.paisa)

    def percent(self, bp: int) -> Money:  # bp = basis points
        return Money(self.paisa * bp // 10000)

    def __str__(self) -> str:
        return f"{self.paisa // 100}.{self.paisa % 100:02d} tk"


class InsufficientBalance(Exception):
    def __str__(self) -> str:
        return "insufficient balance"


class Wallet:
    """An entity: it has an ID and its balance changes over time.
    Encapsulation: _balance is private by convention; change it only through methods."""

    def __init__(self, id: str):
        self.id = id
        self._balance = Money(0)

    def deposit(self, m: Money) -> None:
        self._balance = self._balance.add(m)

    @property
    def balance(self) -> Money:
        return self._balance

    def withdraw(self, m: Money) -> None:
        if self._balance.paisa < m.paisa:
            raise InsufficientBalance()
        self._balance = self._balance.sub(m)


class PaymentMethod(Protocol):
    """Abstraction: checkout only knows 'something that can pay'."""
    name: str

    def pay(self, amount: Money) -> Money: ...  # returns the fee


class Card:
    name = "card"

    def pay(self, amount: Money) -> Money:
        return amount.percent(150)  # 1.5%


class Bkash:
    name = "bkash"

    def __init__(self, wallet: Wallet):
        self.wallet = wallet

    def pay(self, amount: Money) -> Money:
        fee = amount.percent(185)  # 1.85%
        self.wallet.withdraw(amount.add(fee))
        return fee


class Cash:
    name = "cash"

    def pay(self, amount: Money) -> Money:
        return Money(0)


def checkout(pm: PaymentMethod, amount: Money) -> None:
    """Polymorphism: one call, and each payment method does its own thing."""
    try:
        fee = pm.pay(amount)
        print(f"{pm.name:<6} pays {amount}, fee {fee}")
    except InsufficientBalance as e:
        print(f"{pm.name:<6} pays {amount}: {e}")


w = Wallet("W-1")
w.deposit(Money.taka(500))
print(f"wallet {w.id} balance {w.balance}")
checkout(Card(), Money.taka(1200))
checkout(Bkash(w), Money.taka(300))
print(f"wallet {w.id} balance {w.balance}")
checkout(Bkash(w), Money.taka(300))
checkout(Cash(), Money.taka(80))

print("Taka(5) == Taka(5):", str(Money.taka(5) == Money.taka(5)).lower())
# Entities are the same when their IDs match, even if other fields differ.
loaded = Wallet("W-1")  # e.g. the same wallet loaded again from the database
print("same wallet (by ID):", str(w.id == loaded.id).lower())

// A value object: no identity, never changes, equal when the amounts are equal.
class Money {
  readonly paisa: number;
  constructor(paisa: number) {
    this.paisa = paisa;
  }
  static taka(t: number): Money {
    return new Money(t * 100);
  }
  add(o: Money): Money {
    return new Money(this.paisa + o.paisa);
  }
  sub(o: Money): Money {
    return new Money(this.paisa - o.paisa);
  }
  percent(bp: number): Money {
    return new Money(Math.floor((this.paisa * bp) / 10000)); // bp = basis points
  }
  equals(o: Money): boolean {
    return this.paisa === o.paisa;
  }
  toString(): string {
    return `${Math.floor(this.paisa / 100)}.${String(this.paisa % 100).padStart(2, "0")} tk`;
  }
}

class InsufficientBalance extends Error {
  constructor() {
    super("insufficient balance");
  }
}

// An entity: it has an ID and its balance changes over time.
// Encapsulation: #balance is truly private; change it only through methods.
class Wallet {
  readonly id: string;
  #balance = new Money(0);
  constructor(id: string) {
    this.id = id;
  }
  deposit(m: Money): void {
    this.#balance = this.#balance.add(m);
  }
  get balance(): Money {
    return this.#balance;
  }
  withdraw(m: Money): void {
    if (this.#balance.paisa < m.paisa) throw new InsufficientBalance();
    this.#balance = this.#balance.sub(m);
  }
}

// Abstraction: checkout only knows "something that can pay".
interface PaymentMethod {
  readonly name: string;
  pay(amount: Money): Money; // returns the fee
}

class Card implements PaymentMethod {
  readonly name = "card";
  pay(amount: Money): Money {
    return amount.percent(150); // 1.5%
  }
}

class Bkash implements PaymentMethod {
  readonly name = "bkash";
  readonly wallet: Wallet;
  constructor(wallet: Wallet) {
    this.wallet = wallet;
  }
  pay(amount: Money): Money {
    const fee = amount.percent(185); // 1.85%
    this.wallet.withdraw(amount.add(fee));
    return fee;
  }
}

class Cash implements PaymentMethod {
  readonly name = "cash";
  pay(): Money {
    return new Money(0);
  }
}

// Polymorphism: one call, and each payment method does its own thing.
function checkout(pm: PaymentMethod, amount: Money): void {
  try {
    const fee = pm.pay(amount);
    console.log(`${pm.name.padEnd(6)} pays ${amount}, fee ${fee}`);
  } catch (e) {
    console.log(`${pm.name.padEnd(6)} pays ${amount}: ${(e as Error).message}`);
  }
}

const w = new Wallet("W-1");
w.deposit(Money.taka(500));
console.log(`wallet ${w.id} balance ${w.balance}`);
checkout(new Card(), Money.taka(1200));
checkout(new Bkash(w), Money.taka(300));
console.log(`wallet ${w.id} balance ${w.balance}`);
checkout(new Bkash(w), Money.taka(300));
checkout(new Cash(), Money.taka(80));

console.log("Taka(5) == Taka(5):", Money.taka(5).equals(Money.taka(5)));
// Entities are the same when their IDs match, even if other fields differ.
const loaded = new Wallet("W-1"); // e.g. the same wallet loaded again from the database
console.log("same wallet (by ID):", w.id === loaded.id);

use std::fmt;

// A value object: Copy + PartialEq. No identity, never changes, equal when amounts are equal.
#[derive(Clone, Copy, PartialEq, Debug)]
struct Money { paisa: i64 }

impl Money {
    fn taka(t: i64) -> Money { Money { paisa: t * 100 } }
    fn add(self, o: Money) -> Money { Money { paisa: self.paisa + o.paisa } }
    fn sub(self, o: Money) -> Money { Money { paisa: self.paisa - o.paisa } }
    fn percent(self, bp: i64) -> Money { Money { paisa: self.paisa * bp / 10000 } } // bp = basis points
}

impl fmt::Display for Money {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}.{:02} tk", self.paisa / 100, self.paisa % 100)
    }
}

// An entity: it has an ID and its balance changes over time.
// Encapsulation: `balance` is private to this module; change it only through methods.
struct Wallet { id: String, balance: Money }

impl Wallet {
    fn new(id: &str) -> Wallet { Wallet { id: id.to_string(), balance: Money { paisa: 0 } } }
    fn deposit(&mut self, m: Money) { self.balance = self.balance.add(m); }
    fn balance(&self) -> Money { self.balance }
    fn withdraw(&mut self, m: Money) -> Result<(), String> {
        if self.balance.paisa < m.paisa {
            return Err("insufficient balance".into());
        }
        self.balance = self.balance.sub(m);
        Ok(())
    }
}

// Abstraction: checkout only knows "something that can pay".
trait PaymentMethod {
    fn name(&self) -> &str;
    fn pay(&mut self, amount: Money) -> Result<Money, String>; // returns the fee
}

struct Card;
impl PaymentMethod for Card {
    fn name(&self) -> &str { "card" }
    fn pay(&mut self, a: Money) -> Result<Money, String> { Ok(a.percent(150)) } // 1.5%
}

struct Bkash<'a> { wallet: &'a mut Wallet }
impl PaymentMethod for Bkash<'_> {
    fn name(&self) -> &str { "bkash" }
    fn pay(&mut self, a: Money) -> Result<Money, String> {
        let fee = a.percent(185); // 1.85%
        self.wallet.withdraw(a.add(fee))?;
        Ok(fee)
    }
}

struct Cash;
impl PaymentMethod for Cash {
    fn name(&self) -> &str { "cash" }
    fn pay(&mut self, _: Money) -> Result<Money, String> { Ok(Money { paisa: 0 }) }
}

// Polymorphism: one call (through a trait object), and each method does its own thing.
fn checkout(pm: &mut dyn PaymentMethod, amount: Money) {
    match pm.pay(amount) {
        Ok(fee) => println!("{:<6} pays {amount}, fee {fee}", pm.name()),
        Err(e) => println!("{:<6} pays {amount}: {e}", pm.name()),
    }
}

fn main() {
    let mut w = Wallet::new("W-1");
    w.deposit(Money::taka(500));
    println!("wallet {} balance {}", w.id, w.balance());
    checkout(&mut Card, Money::taka(1200));
    checkout(&mut Bkash { wallet: &mut w }, Money::taka(300));
    println!("wallet {} balance {}", w.id, w.balance());
    checkout(&mut Bkash { wallet: &mut w }, Money::taka(300));
    checkout(&mut Cash, Money::taka(80));

    println!("Taka(5) == Taka(5): {}", Money::taka(5) == Money::taka(5));
    // Entities are the same when their IDs match, even if other fields differ.
    let loaded = Wallet::new("W-1"); // e.g. the same wallet loaded again from the database
    println!("same wallet (by ID): {}", w.id == loaded.id);
}

public class Main {
    // A value object: a record is immutable and compares by its fields.
    record Money(long paisa) {
        static Money taka(long t) { return new Money(t * 100); }
        Money add(Money o) { return new Money(paisa + o.paisa); }
        Money sub(Money o) { return new Money(paisa - o.paisa); }
        Money percent(long bp) { return new Money(paisa * bp / 10000); } // bp = basis points
        @Override public String toString() { return String.format("%d.%02d tk", paisa / 100, paisa % 100); }
    }

    static final class InsufficientBalance extends Exception {
        private static final long serialVersionUID = 1L;
        InsufficientBalance() { super("insufficient balance"); }
    }

    // An entity: it has an ID and its balance changes over time.
    // Encapsulation: balance is private; change it only through methods.
    static final class Wallet {
        final String id;
        private Money balance = new Money(0);
        Wallet(String id) { this.id = id; }
        void deposit(Money m) { balance = balance.add(m); }
        Money balance() { return balance; }
        void withdraw(Money m) throws InsufficientBalance {
            if (balance.paisa() < m.paisa()) throw new InsufficientBalance();
            balance = balance.sub(m);
        }
    }

    // Abstraction: checkout only knows "something that can pay".
    interface PaymentMethod {
        String name();
        Money pay(Money amount) throws InsufficientBalance; // returns the fee
    }

    static final class Card implements PaymentMethod {
        public String name() { return "card"; }
        public Money pay(Money a) { return a.percent(150); } // 1.5%
    }

    static final class Bkash implements PaymentMethod {
        private final Wallet wallet;
        Bkash(Wallet wallet) { this.wallet = wallet; }
        public String name() { return "bkash"; }
        public Money pay(Money a) throws InsufficientBalance {
            Money fee = a.percent(185); // 1.85%
            wallet.withdraw(a.add(fee));
            return fee;
        }
    }

    static final class Cash implements PaymentMethod {
        public String name() { return "cash"; }
        public Money pay(Money a) { return new Money(0); }
    }

    // Polymorphism: one call, and each payment method does its own thing.
    static void checkout(PaymentMethod pm, Money amount) {
        try {
            Money fee = pm.pay(amount);
            System.out.printf("%-6s pays %s, fee %s%n", pm.name(), amount, fee);
        } catch (InsufficientBalance e) {
            System.out.printf("%-6s pays %s: %s%n", pm.name(), amount, e.getMessage());
        }
    }

    public static void main(String[] args) {
        Wallet w = new Wallet("W-1");
        w.deposit(Money.taka(500));
        System.out.printf("wallet %s balance %s%n", w.id, w.balance());
        checkout(new Card(), Money.taka(1200));
        checkout(new Bkash(w), Money.taka(300));
        System.out.printf("wallet %s balance %s%n", w.id, w.balance());
        checkout(new Bkash(w), Money.taka(300));
        checkout(new Cash(), Money.taka(80));

        System.out.println("Taka(5) == Taka(5): " + Money.taka(5).equals(Money.taka(5)));
        // Entities are the same when their IDs match, even if other fields differ.
        Wallet loaded = new Wallet("W-1"); // e.g. the same wallet loaded again from the database
        System.out.println("same wallet (by ID): " + w.id.equals(loaded.id));
    }
}

#include <cstdio>
#include <stdexcept>
#include <string>

// A value object: no identity, never changes, equal when the amounts are equal.
struct Money {
    long long paisa = 0;
    static Money taka(long long t) { return {t * 100}; }
    Money add(Money o) const { return {paisa + o.paisa}; }
    Money sub(Money o) const { return {paisa - o.paisa}; }
    Money percent(long long bp) const { return {paisa * bp / 10000}; }  // bp = basis points
    bool operator==(const Money&) const = default;
    std::string str() const {
        char buf[32];
        std::snprintf(buf, sizeof buf, "%lld.%02lld tk", paisa / 100, paisa % 100);
        return buf;
    }
};

struct InsufficientBalance : std::runtime_error {
    InsufficientBalance() : std::runtime_error("insufficient balance") {}
};

// An entity: it has an ID and its balance changes over time.
// Encapsulation: balance_ is private; change it only through methods.
class Wallet {
public:
    explicit Wallet(std::string id) : id(std::move(id)) {}
    const std::string id;
    void deposit(Money m) { balance_ = balance_.add(m); }
    Money balance() const { return balance_; }
    void withdraw(Money m) {
        if (balance_.paisa < m.paisa) throw InsufficientBalance();
        balance_ = balance_.sub(m);
    }

private:
    Money balance_;
};

// Abstraction: checkout only knows "something that can pay".
class PaymentMethod {
public:
    virtual ~PaymentMethod() = default;
    virtual const char* name() const = 0;
    virtual Money pay(Money amount) = 0;  // returns the fee
};

class Card : public PaymentMethod {
public:
    const char* name() const override { return "card"; }
    Money pay(Money a) override { return a.percent(150); }  // 1.5%
};

class Bkash : public PaymentMethod {
public:
    explicit Bkash(Wallet& w) : wallet_(w) {}
    const char* name() const override { return "bkash"; }
    Money pay(Money a) override {
        Money fee = a.percent(185);  // 1.85%
        wallet_.withdraw(a.add(fee));
        return fee;
    }

private:
    Wallet& wallet_;
};

class Cash : public PaymentMethod {
public:
    const char* name() const override { return "cash"; }
    Money pay(Money) override { return {}; }
};

// Polymorphism: one call (a virtual function), and each method does its own thing.
void checkout(PaymentMethod& pm, Money amount) {
    try {
        Money fee = pm.pay(amount);
        std::printf("%-6s pays %s, fee %s\n", pm.name(), amount.str().c_str(), fee.str().c_str());
    } catch (const InsufficientBalance& e) {
        std::printf("%-6s pays %s: %s\n", pm.name(), amount.str().c_str(), e.what());
    }
}

int main() {
    Wallet w("W-1");
    w.deposit(Money::taka(500));
    std::printf("wallet %s balance %s\n", w.id.c_str(), w.balance().str().c_str());
    Card card;
    Bkash bkash(w);
    Cash cash;
    checkout(card, Money::taka(1200));
    checkout(bkash, Money::taka(300));
    std::printf("wallet %s balance %s\n", w.id.c_str(), w.balance().str().c_str());
    checkout(bkash, Money::taka(300));
    checkout(cash, Money::taka(80));

    std::printf("Taka(5) == Taka(5): %s\n", Money::taka(5) == Money::taka(5) ? "true" : "false");
    // Entities are the same when their IDs match, even if other fields differ.
    Wallet loaded("W-1");  // e.g. the same wallet loaded again from the database
    std::printf("same wallet (by ID): %s\n", w.id == loaded.id ? "true" : "false");
}