Low-Level Design (LLD)

from abc import ABC, abstractmethod
from enum import Enum
 
class SpotSize(Enum):
    SMALL, MEDIUM, LARGE = 1, 2, 3
 
class Vehicle(ABC):                 # abstract base — the "is-a" root
    def __init__(self, plate): self.plate = plate
    @abstractmethod
    def size(self) -> SpotSize: ...
 
class Car(Vehicle):                 # add a new subclass to extend — Open/Closed
    def size(self): return SpotSize.MEDIUM
 
class PaymentStrategy(ABC):         # Strategy pattern — swap at runtime
    @abstractmethod
    def pay(self, amount: float) -> bool: ...
 
class CardPayment(PaymentStrategy):
    def pay(self, amount): ...      # charge a card
 
class ParkingSpot:
    def __init__(self, size): self.size, self.is_free = size, True
 
class ParkingLot:                   # Singleton: one lot for the system
    def park_vehicle(self, v: Vehicle) -> "Ticket": ...   # find spot, issue ticket
    def unpark(self, ticket, payment: PaymentStrategy): ...  # price + pay + free spot

enum SpotSize { SMALL, MEDIUM, LARGE }
 
abstract class Vehicle {                    // "is-a" root
    String plate;
    abstract SpotSize size();
}
class Car extends Vehicle {                 // extend without editing — Open/Closed
    SpotSize size() { return SpotSize.MEDIUM; }
}
 
interface PaymentStrategy {                 // Strategy: swap implementations
    boolean pay(double amount);
}
class CardPayment implements PaymentStrategy {
    public boolean pay(double amount) { /* charge */ return true; }
}
 
class ParkingSpot { SpotSize size; boolean isFree = true; }
 
class ParkingLot {                          // Singleton
    Ticket parkVehicle(Vehicle v) { /* find spot, issue ticket */ return null; }
    void unpark(Ticket t, PaymentStrategy p) { /* price, pay, free spot */ }
}