Parking Lot Design

Let's define the functional and non-functional requirements for a parking lot system.

Functional Requirements

1. Support multiple vehicle types:
   - Motorcycle, Car, Truck

2. Multiple floors with parking spots:
   - Each floor has different spot types
   - Spot types: Compact, Regular, Large

3. Vehicle entry/exit:
   - Ticket issued on entry
   - Payment processed on exit

4. Parking spot allocation:
   - Assign appropriate spot for vehicle type
   - Track available spots per floor

5. Pricing:
   - Different rates per vehicle type
   - Time-based pricing

6. Display boards:
   - Show available spots per floor
   - Show total available spots

Non-Functional Requirements

1. Concurrency: Multiple entry/exit panels simultaneously
2. Scalability: Support 1000s of vehicles
3. Availability: 99.9% uptime
4. Real-time: Spot availability updated immediately

Core Entities

Vehicle, ParkingSpot, ParkingFloor, ParkingLot,
Ticket, Payment, VehicleType, SpotType

Key Workflows

Entry Flow:
Vehicle arrives → Select vehicle type → Check availability
→ Allocate spot → Issue ticket → Open gate → Vehicle enters

Exit Flow:
Vehicle at gate → Scan ticket → Calculate duration
→ Calculate fee → Process payment → Release spot → Open gate

Let's design the classes and their relationships.

Class Diagram

┌──────────────────────────────────────────────┐
│              ParkingLot (Singleton)           │
├──────────────────────────────────────────────┤
│ - floors: List<ParkingFloor>                 │
│ - displayBoard: DisplayBoard                 │
├──────────────────────────────────────────────┤
│ + getParkingSpot(type): ParkingSpot          │
│ + releaseSpot(spot): void                    │
│ + getAvailableSpots(): int                   │
└──────────────────────────────────────────────┘
              │ 1
              │ has many
              ▼ *
┌──────────────────────────────────────────────┐
│            ParkingFloor                       │
├──────────────────────────────────────────────┤
│ - floorNumber: int                           │
│ - spots: List<ParkingSpot>                   │
│ - displayBoard: DisplayBoard                 │
├──────────────────────────────────────────────┤
│ + getAvailableSpot(type): ParkingSpot        │
│ + getAvailableCount(type): int               │
└──────────────────────────────────────────────┘
              │ 1
              │ has many
              ▼ *
┌──────────────────────────────────────────────┐
│            ParkingSpot                        │
├──────────────────────────────────────────────┤
│ - spotNumber: String                         │
│ - spotType: SpotType                         │
│ - vehicle: Vehicle (nullable)                │
│ - isOccupied: boolean                        │
├──────────────────────────────────────────────┤
│ + park(vehicle): boolean                     │
│ + remove(): Vehicle                          │
│ + isAvailableFor(type): boolean              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│            Vehicle                             │
├──────────────────────────────────────────────┤
│ - licensePlate: String                       │
│ - type: VehicleType                          │
│ - ticket: Ticket (nullable)                  │
├──────────────────────────────────────────────┤
│ + getType(): VehicleType                     │
│ + getLicensePlate(): String                  │
└──────────────────────────────────────────────┘

Enums

public enum VehicleType {
    MOTORCYCLE, CAR, TRUCK
}

public enum SpotType {
    COMPACT, REGULAR, LARGE
}

public enum PaymentStatus {
    PENDING, COMPLETED, FAILED
}

Vehicle-Spot Mapping

VehicleType → Required SpotType
MOTORCYCLE  → COMPACT (or larger)
CAR         → REGULAR (or larger)
TRUCK       → LARGE only

Hierarchy: COMPACT < REGULAR < LARGE

Key implementation details for the parking lot system.

ParkingLot Singleton

public class ParkingLot {
    private static ParkingLot instance;
    private List<ParkingFloor> floors;
    
    private ParkingLot() {
        this.floors = new ArrayList<>();
    }
    
    public static synchronized ParkingLot getInstance() {
        if (instance == null) {
            instance = new ParkingLot();
        }
        return instance;
    }
    
    public ParkingSpot findSpot(VehicleType type) {
        for (ParkingFloor floor : floors) {
            ParkingSpot spot = floor.getAvailableSpot(type);
            if (spot != null) {
                return spot;
            }
        }
        return null; // No spot available
    }
}

ParkingSpot with Strategy

public class ParkingSpot {
    private final String spotNumber;
    private final SpotType spotType;
    private Vehicle vehicle;
    
    public boolean canFit(VehicleType vehicleType) {
        return spotType.canFit(vehicleType);
    }
    
    public boolean park(Vehicle vehicle) {
        if (!canFit(vehicle.getType()) || vehicle != null) {
            return false;
        }
        this.vehicle = vehicle;
        return true;
    }
    
    public Vehicle remove() {
        Vehicle v = this.vehicle;
        this.vehicle = null;
        return v;
    }
}

Ticket System

public class Ticket {
    private final String ticketId;
    private final Vehicle vehicle;
    private final ParkingSpot spot;
    private final LocalDateTime entryTime;
    private LocalDateTime exitTime;
    
    public Ticket(Vehicle vehicle, ParkingSpot spot) {
        this.ticketId = UUID.randomUUID().toString();
        this.vehicle = vehicle;
        this.spot = spot;
        this.entryTime = LocalDateTime.now();
    }
    
    public Money calculateFee(PricingStrategy pricing) {
        long hours = Duration.between(entryTime, 
            exitTime != null ? exitTime : LocalDateTime.now()).toHours();
        return pricing.calculate(vehicle.getType(), hours);
    }
}

Pricing Strategy

public interface PricingStrategy {
    Money calculate(VehicleType type, long hours);
}

public class HourlyPricing implements PricingStrategy {
    private static final Map<VehicleType, Money> RATES = Map.of(
        VehicleType.MOTORCYCLE, new Money(2, "USD"),
        VehicleType.CAR, new Money(5, "USD"),
        VehicleType.TRUCK, new Money(10, "USD")
    );
    
    public Money calculate(VehicleType type, long hours) {
        return RATES.get(type).multiply(hours);
    }
}

Common follow-up questions and extensions.

Follow-up Questions

1. How to handle multiple entry/exit points?
   → Each panel communicates with central ParkingLot
   → Use thread-safe data structures

2. How to handle payment processing?
   → PaymentProcessor interface with multiple implementations
   → Cash, Credit Card, Mobile Payment

3. How to handle reserved parking?
   → Add Reservation class
   → Spot can be reserved for specific time

4. How to handle EV charging spots?
   → Add Charger interface
   → SpotType.EV_CHARGING

5. How to display real-time availability?
   → Observer pattern
   → DisplayBoard updates on park/remove

Design Patterns Used

Pattern	Where Used
Singleton	ParkingLot (one instance)
Strategy	PricingStrategy (different rates)
Observer	DisplayBoard (updates on changes)
Factory	Vehicle creation
State	Ticket states (active, completed)

Scaling Considerations

1. Multiple parking lots:
   → ParkingLotManager manages multiple lots

2. Reservation system:
   → Add booking API
   → Time-slot based reservation

3. Real-time mobile app:
   → WebSocket for live updates
   → Find my car feature

4. Analytics:
   → Track usage patterns
   → Peak hours analysis

5. Integration:
   → Payment gateway
   → SMS notifications