OOP: Classes, Inheritance & Polymorphism

class BankAccount:
    """A simple bank account class."""
    bank_name = "National Bank"  # class attribute (shared)

    def __init__(self, owner: str, balance: float = 0.0):
        self.owner = owner        # instance attribute
        self.balance = balance    # instance attribute

    def deposit(self, amount: float) -> float:
        """Add money to the account."""
        self.balance += amount
        return self.balance

    def withdraw(self, amount: float) -> float:
        """Withdraw money if sufficient balance."""
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        return self.balance

# Creating objects (instances)
alice_acc = BankAccount("Alice", 1000.0)
bob_acc = BankAccount("Bob", 500.0)

print(alice_acc.owner)      # Alice
print(bob_acc.bank_name)    # National Bank (shared)
alice_acc.deposit(250)      # 1250.0
bob_acc.withdraw(100)       # 400.0

class Temperature:
    def __init__(self, celsius: float):
        self._celsius = celsius  # protected attribute (convention)

    @property
    def celsius(self) -> float:
        """Getter – allows read access."""
        return self._celsius

    @celsius.setter
    def celsius(self, value: float):
        """Setter – validates before setting."""
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self) -> float:
        """Computed property – no setter needed."""
        return self._celsius * 9/5 + 32

temp = Temperature(25)
print(temp.celsius)       # 25 (via getter)
print(temp.fahrenheit)    # 77.0 (computed)
temp.celsius = 100        # via setter (validation passes)
# temp.celsius = -500     # ❌ ValueError: Below absolute zero!

class Employee:
    def __init__(self, name: str, salary: float):
        self.name = name
        self.salary = salary

    def work(self) -> str:
        return f"{self.name} is working."

    def get_annual_bonus(self) -> float:
        return self.salary * 0.10  # 10% bonus

class Developer(Employee):
    def __init__(self, name: str, salary: float, language: str):
        super().__init__(name, salary)  # call parent constructor
        self.language = language

    def work(self) -> str:  # override parent method
        return f"{self.name} is coding in {self.language}."

    def get_annual_bonus(self) -> float:
        return self.salary * 0.15  # developers get 15%

class Manager(Employee):
    def __init__(self, name: str, salary: float, team_size: int):
        super().__init__(name, salary)
        self.team_size = team_size

    def work(self) -> str:
        return f"{self.name} is managing a team of {self.team_size}."

dev = Developer("Alice", 80000, "Python")
mgr = Manager("Bob", 100000, 5)
print(dev.work())            # Alice is coding in Python.
print(mgr.get_annual_bonus())  # 10000.0

class PayPal:
    def pay(self, amount: float) -> str:
        return f"Paid ${amount:.2f} via PayPal."

class Stripe:
    def pay(self, amount: float) -> str:
        return f"Paid ${amount:.2f} via Stripe."

class CryptoWallet:
    def pay(self, amount: float) -> str:
        return f"Paid ${amount:.2f} via Crypto."

def process_payment(payment_method, amount: float):
    """Works with ANY object that has a pay() method."""
    return payment_method.pay(amount)

# All three work — polymorphic behavior
print(process_payment(PayPal(), 99.99))      # Paid $99.99 via PayPal.
print(process_payment(Stripe(), 49.50))      # Paid $49.50 via Stripe.
print(process_payment(CryptoWallet(), 200))   # Paid $200.00 via Crypto.

from dataclasses import dataclass

class Vector:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

    def __repr__(self) -> str:          # unambiguous representation
        return f"Vector({self.x}, {self.y})"

    def __str__(self) -> str:           # human‑readable
        return f"({self.x}, {self.y})"

    def __add__(self, other: 'Vector') -> 'Vector':
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other: 'Vector') -> bool:
        return self.x == other.x and self.y == other.y

    def __abs__(self) -> float:
        return (self.x**2 + self.y**2) ** 0.5

v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1 + v2)       # (4, 6)
print(abs(v1))       # 5.0
print(v1 == Vector(3, 4))  # True

from dataclasses import dataclass, field
from abc import ABC, abstractmethod

# Dataclass – reduces boilerplate
@dataclass(frozen=True)  # immutable
class Point:
    x: float
    y: float
    label: str = "origin"  # default value

# Abstract Base Class – enforces interface
class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

    @abstractmethod
    def perimeter(self) -> float:
        pass

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius
    def area(self) -> float:
        return 3.14159 * self.radius ** 2
    def perimeter(self) -> float:
        return 2 * 3.14159 * self.radius

# Mixin – reusable behavior
class LoggerMixin:
    def log(self, message: str):
        print(f"[{self.__class__.__name__}] {message}")

class DatabaseConnection(LoggerMixin):
    def connect(self):
        self.log("Connecting to database...")
        # connection logic here

db = DatabaseConnection()
db.connect()  # [DatabaseConnection] Connecting to database...

# 1. FACTORY PATTERN – create objects without specifying exact class
class PaymentFactory:
    @staticmethod
    def create(method: str):
        if method == "paypal":
            return PayPal()
        elif method == "stripe":
            return Stripe()
        raise ValueError(f"Unknown method: {method}")

# 2. SINGLETON PATTERN – ensure only one instance exists
class DatabasePool:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connections = []
        return cls._instance

# 3. DEPENDENCY INJECTION – pass dependencies instead of hardcoding
class EmailService:
    def send(self, to: str, body: str):
        print(f"Sending email to {to}: {body}")

class UserRegistration:
    def __init__(self, email_service: EmailService):
        self.email_service = email_service  # injected dependency

    def register(self, user_email: str):
        # registration logic...
        self.email_service.send(user_email, "Welcome!")

# Usage
email_svc = EmailService()
registration = UserRegistration(email_svc)
registration.register("alice@example.com")