Parking Lot

Clarify Requirements

Imagine you're at a busy mall on a Saturday afternoon. Cars are streaming in, motorcycles are weaving through, the security guard is waving people up to floor 2 because floor 1 is full, and an electric SUV is hunting for a charger. Every one of those flows is something the parking lot has to handle. Before we draw a single class, we lock down what's in scope and what isn't — that's how an interviewer hears that you've thought about the problem, not just the code.

Actors & Use Cases

Before nouns become classes, we ask: who is doing things in this system, and what do they do? Four humans interact with the lot directly, and one silent actor — the System itself — runs the display board, the allocator, and the clock. Drawing these as a flowchart (instead of just listing them) makes the boundary between human-driven and system-driven actions visible at a glance.

Story — From a Paper-Ticket Booth to a Smart Lot

The fastest way to design a parking lot is to start with the dumbest version that could plausibly work, watch it break, and let each break suggest the next class. We do this in three passes: the naive design, the mental split that fixes it, and the production shape. Every box you'll see in the class diagram later was put there because something concrete broke without it.

Pass 1 — The naive design (and why it breaks)

You start with a single-floor lot, one gate, one attendant Raj at the booth with a stack of paper tickets and a clock. Cars come in, Raj scribbles the entry time on a ticket, hands it over. Cars leave, Raj reads the time, computes the fee on a calculator, accepts cash. Done. Code-wise this is one class with a list of spots and a HashMap of active tickets.

Then reality hits:

Pass 2 — The mental split

Every failure above maps to one of two concerns the booth was conflating:

That single split — inventory vs transaction — is the spine of the design. Anything in the inventory plane mutates a shared map under a lock; anything in the transaction plane is a per-ticket state machine that doesn't need to fight with anyone else for a lock.

Pass 3 — The production shape

Now we build the full architecture. Each numbered box below earns its place by fixing one of the failures from Pass 1. Read the badge color on each card to find the matching box in the diagram.

Component-by-component — what each numbered box does

Use the numbers in the diagram to find the matching card. Each card answers four questions: what is it, why does it exist, what would break without it, and what does it talk to.

Core Entities

Now we name every noun. For each one we say one sentence about its responsibility and list the 3–5 fields it absolutely needs. Methods come later in the class diagram — for now, just attributes.

ER / Schema Diagram

Even though the in-memory design doesn't strictly need a database, drawing the ER tells you the persistence shape — and in an interview it shows you separated identity from references. Read each line as "one X owns many Y" or "one X belongs to one Y".

Read the cardinality: one Lot has many Floors. One Floor has many Spots and many Gates. A Spot can hold zero or one Ticket at any moment (the ||--o|). A Vehicle is identified by its plate and can have many tickets across visits. A Ticket can have multiple Payment attempts (because the first one might fail).

Class Diagram

Now we wire methods, inheritance, and relationships. Pay attention to which arrows are inheritance (<|--), which are composition (*--), and which are association (-->). The split between abstract Vehicle/ParkingSpot/Account and their concrete subclasses is what lets the lot work with "any vehicle" and "any spot" without caring about the concrete type.

Design Patterns Used

An interviewer will absolutely ask "where are the patterns?". Here are the six that earn their keep — pattern name, who plays it, and the single sentence that justifies it.

Sequence — Entry & Exit

Here's the happy path for the most important flow: a car drives in, parks for an hour, drives out. Watch where the synchronization lives — it's only on the spot allocation. Pricing and payment are per-ticket and need no lock.

Flow A — Sarah parks her Honda

Flow B — Sarah leaves an hour later

State Diagram — ParkingTicket

The ticket is the entity with the most lifecycle complexity. Without a state diagram you'll write code that lets you "pay an exited ticket" or "exit without paying". Each arrow is a method on ParkingTicket; the methods in any other state throw IllegalTicketStateException.

Java Implementation

Java 17+. No frameworks. Showing the parts that demonstrate the patterns and the concurrency story; a real implementation would also have factories, persistence, and gates. Code order: enums → interfaces → entities → strategies → orchestrator → demo.

public enum VehicleType { MOTORCYCLE, CAR, VAN, TRUCK, ELECTRIC_CAR }

public enum SpotType { MOTORCYCLE, COMPACT, LARGE, ELECTRIC, HANDICAPPED }

public enum TicketStatus { ACTIVE, PAID, EXITED, LOST }

public enum PaymentMethod { CASH, CARD }

public enum PaymentStatus { PENDING, SUCCESS, FAILED }

public abstract class Vehicle {
  private final String licensePlate;
  private final VehicleType type;
  protected Vehicle(String plate, VehicleType t) {
    this.licensePlate = plate; this.type = t;
  }
  public String getLicensePlate() { return licensePlate; }
  public VehicleType getType() { return type; }
}
public class Car         extends Vehicle { public Car(String p)         { super(p, VehicleType.CAR); } }
public class Motorcycle  extends Vehicle { public Motorcycle(String p)  { super(p, VehicleType.MOTORCYCLE); } }
public class Truck       extends Vehicle { public Truck(String p)       { super(p, VehicleType.TRUCK); } }
public class Van         extends Vehicle { public Van(String p)         { super(p, VehicleType.VAN); } }
public class ElectricCar extends Vehicle { public ElectricCar(String p) { super(p, VehicleType.ELECTRIC_CAR); } }

public abstract class ParkingSpot {
  private final String spotId;
  private final SpotType type;
  private Vehicle vehicle;
  private boolean free = true;

  protected ParkingSpot(String id, SpotType t) { this.spotId = id; this.type = t; }

  public abstract boolean fits(Vehicle v);

  public synchronized void assign(Vehicle v) {
    if (!free) throw new IllegalStateException("spot already taken");
    if (!fits(v)) throw new IllegalArgumentException("vehicle does not fit");
    this.vehicle = v; this.free = false;
  }
  public synchronized void release() { this.vehicle = null; this.free = true; }
  public boolean isFree() { return free; }
  public SpotType getType() { return type; }
  public String getId() { return spotId; }
}

public class CompactSpot extends ParkingSpot {
  public CompactSpot(String id) { super(id, SpotType.COMPACT); }
  public boolean fits(Vehicle v) {
    return v.getType() == VehicleType.CAR
        || v.getType() == VehicleType.ELECTRIC_CAR;
  }
}
public class LargeSpot extends ParkingSpot {
  public LargeSpot(String id) { super(id, SpotType.LARGE); }
  public boolean fits(Vehicle v) {
    return v.getType() != VehicleType.MOTORCYCLE; // fits everything except bikes
  }
}
public class MotorcycleSpot extends ParkingSpot {
  public MotorcycleSpot(String id) { super(id, SpotType.MOTORCYCLE); }
  public boolean fits(Vehicle v) { return v.getType() == VehicleType.MOTORCYCLE; }
}
public class ElectricSpot extends ParkingSpot {
  public ElectricSpot(String id) { super(id, SpotType.ELECTRIC); }
  public boolean fits(Vehicle v) { return v.getType() == VehicleType.ELECTRIC_CAR; }
}

public interface SpotAllocationStrategy {
  Optional<ParkingSpot> allocate(Vehicle v, List<ParkingFloor> floors);
}

public class NearestFirstStrategy implements SpotAllocationStrategy {
  public Optional<ParkingSpot> allocate(Vehicle v, List<ParkingFloor> floors) {
    return floors.stream()                  // floors are sorted by proximity to entry
      .map(f -> f.findFreeSpot(v))
      .filter(Optional::isPresent)
      .map(Optional::get)
      .findFirst();
  }
}

public class BestFitStrategy implements SpotAllocationStrategy {
  public Optional<ParkingSpot> allocate(Vehicle v, List<ParkingFloor> floors) {
    // EV → Electric → Compact → Large; Car → Compact → Large; Truck/Van → Large
    List<SpotType> preference = switch (v.getType()) {
      case ELECTRIC_CAR -> List.of(SpotType.ELECTRIC, SpotType.COMPACT, SpotType.LARGE);
      case CAR          -> List.of(SpotType.COMPACT, SpotType.LARGE);
      case MOTORCYCLE   -> List.of(SpotType.MOTORCYCLE);
      case VAN, TRUCK   -> List.of(SpotType.LARGE);
    };
    for (SpotType pref : preference)
      for (ParkingFloor f : floors) {
        Optional<ParkingSpot> s = f.findFreeSpotOfType(pref, v);
        if (s.isPresent()) return s;
      }
    return Optional.empty();
  }
}

public interface PricingStrategy {
  BigDecimal price(LocalDateTime entry, LocalDateTime exit, VehicleType type);
}

public class FlatRateStrategy implements PricingStrategy {
  private final BigDecimal ratePerHour;
  public FlatRateStrategy(BigDecimal r) { this.ratePerHour = r; }
  public BigDecimal price(LocalDateTime entry, LocalDateTime exit, VehicleType t) {
    long hours = Math.max(1, Duration.between(entry, exit).toHours());
    return ratePerHour.multiply(BigDecimal.valueOf(hours));
  }
}

public class TieredRateStrategy implements PricingStrategy {
  // 1st hour ₹40, hours 2-3 ₹30 each, 4+ ₹20 each
  public BigDecimal price(LocalDateTime entry, LocalDateTime exit, VehicleType t) {
    long h = Math.max(1, Duration.between(entry, exit).toHours());
    BigDecimal total = BigDecimal.valueOf(40);
    if (h > 1) total = total.add(BigDecimal.valueOf(Math.min(h - 1, 2) * 30));
    if (h > 3) total = total.add(BigDecimal.valueOf((h - 3) * 20));
    return total;
  }
}

public class PeakHourStrategy implements PricingStrategy {
  // Decorator-style: wraps another strategy, applies 1.5x for any hour overlapping 18:00–21:00
  private final PricingStrategy inner;
  public PeakHourStrategy(PricingStrategy inner) { this.inner = inner; }
  public BigDecimal price(LocalDateTime entry, LocalDateTime exit, VehicleType t) {
    BigDecimal base = inner.price(entry, exit, t);
    boolean peakOverlap = entry.getHour() < 21 && exit.getHour() >= 18;
    return peakOverlap ? base.multiply(BigDecimal.valueOf(1.5)) : base;
  }
}

public class ParkingTicket {
  private final String ticketId;
  private final String licensePlate;
  private final String spotId;
  private final LocalDateTime entryTime;
  private LocalDateTime exitTime;
  private TicketStatus status = TicketStatus.ACTIVE;
  private BigDecimal amount = BigDecimal.ZERO;

  public ParkingTicket(String plate, String spotId) {
    this.ticketId = UUID.randomUUID().toString();
    this.licensePlate = plate;
    this.spotId = spotId;
    this.entryTime = LocalDateTime.now();
  }

  public synchronized void markPaid(BigDecimal amt) {
    if (status != TicketStatus.ACTIVE && status != TicketStatus.LOST)
      throw new IllegalStateException("cannot pay ticket in state " + status);
    this.amount = amt;
    this.status = TicketStatus.PAID;
  }
  public synchronized void markLost() {
    if (status != TicketStatus.ACTIVE)
      throw new IllegalStateException("only ACTIVE tickets can be marked LOST");
    this.status = TicketStatus.LOST;
  }
  public synchronized void markExited() {
    if (status != TicketStatus.PAID)
      throw new IllegalStateException("must pay before exit, current=" + status);
    this.exitTime = LocalDateTime.now();
    this.status = TicketStatus.EXITED;
  }
  // getters omitted
}

public record SpotEvent(SpotType type, boolean nowFree) {}

public interface SpotListener { void onSpotChanged(SpotEvent e); }

public class DisplayBoard implements SpotListener {
  private final String floorId;
  private final Map<SpotType, AtomicInteger> freeCounts = new EnumMap<>(SpotType.class);
  public DisplayBoard(String floorId, Map<SpotType, Integer> initial) {
    this.floorId = floorId;
    initial.forEach((k, v) -> freeCounts.put(k, new AtomicInteger(v)));
  }
  public void onSpotChanged(SpotEvent e) {
    freeCounts.get(e.type()).addAndGet(e.nowFree() ? 1 : -1);
  }
  public String render() {
    StringBuilder sb = new StringBuilder("Floor ").append(floorId).append(" — ");
    freeCounts.forEach((k, v) -> sb.append(k).append(":").append(v.get()).append(" "));
    return sb.toString();
  }
}

public class ParkingLot {
  private static volatile ParkingLot instance;
  public static ParkingLot getInstance() {
    if (instance == null) synchronized (ParkingLot.class) {
      if (instance == null) instance = new ParkingLot();
    }
    return instance;
  }

  private final List<ParkingFloor> floors = new ArrayList<>();
  private final Map<String, ParkingTicket> activeTickets = new ConcurrentHashMap<>();
  private final Map<String, String> plateIndex = new ConcurrentHashMap<>(); // for lost-ticket lookup
  private SpotAllocationStrategy allocator = new BestFitStrategy();
  private PricingStrategy pricer = new PeakHourStrategy(new TieredRateStrategy());
  private final BigDecimal lostPenalty = new BigDecimal("200");

  public synchronized ParkingTicket issueTicket(Vehicle v) {
    ParkingSpot spot = allocator.allocate(v, floors)
      .orElseThrow(() -> new IllegalStateException("lot full for " + v.getType()));
    spot.assign(v);
    ParkingTicket t = new ParkingTicket(v.getLicensePlate(), spot.getId());
    activeTickets.put(t.getTicketId(), t);
    plateIndex.put(v.getLicensePlate(), t.getTicketId());
    notifyFloorOf(spot, false); // emits SpotEvent → DisplayBoard
    return t;
  }

  public Payment closeTicket(String ticketId, PaymentMethod method) {
    ParkingTicket t = Optional.ofNullable(activeTickets.get(ticketId))
      .orElseThrow(() -> new NoSuchElementException("unknown ticket"));
    BigDecimal fee = pricer.price(t.getEntryTime(), LocalDateTime.now(), lookupVehicleType(t));
    if (t.getStatus() == TicketStatus.LOST) fee = fee.add(lostPenalty);
    Payment p = new Payment(fee, method);
    if (!p.process()) throw new PaymentFailedException(p);
    t.markPaid(fee);
    t.markExited();
    releaseSpot(t.getSpotId());
    activeTickets.remove(ticketId);
    plateIndex.remove(t.getLicensePlate());
    return p;
  }

  public ParkingTicket reportLostTicket(String licensePlate) {
    String ticketId = Optional.ofNullable(plateIndex.get(licensePlate))
      .orElseThrow(() -> new NoSuchElementException("no active ticket for plate"));
    ParkingTicket t = activeTickets.get(ticketId);
    t.markLost();
    return t;
  }

  // admin hooks for hot-swapping strategies — Open/Closed in action
  public void setAllocator(SpotAllocationStrategy s) { this.allocator = s; }
  public void setPricer(PricingStrategy p)        { this.pricer = p; }
  // notifyFloorOf, releaseSpot, lookupVehicleType helpers omitted
}

public class Demo {
  public static void main(String[] args) {
    ParkingLot lot = ParkingLot.getInstance();
    // admin pre-seeds floors & spots elsewhere…

    Vehicle sarahCar = new Car("DL-3C-AA-1234");
    ParkingTicket t1 = lot.issueTicket(sarahCar);
    System.out.println("Sarah parked at " + t1.getSpotId());

    // Sarah loses her ticket
    ParkingTicket recovered = lot.reportLostTicket("DL-3C-AA-1234");
    System.out.println("Recovered ticket " + recovered.getTicketId() + ", state=" + recovered.getStatus());

    // pays at exit (penalty included)
    Payment p = lot.closeTicket(recovered.getTicketId(), PaymentMethod.CARD);
    System.out.println("Sarah paid ₹" + p.getAmount());
  }
}

Intuition — How to arrive at this design from scratch

If an interviewer asks you to solve this cold, this is the order to think it. You won't reach for Strategy and Observer because you remembered them — you'll reach for them because the problem keeps pushing you there.

Improvements over the Grokking Reference Design

The "Grokking the Object Oriented Design Interview" design is the canonical answer most candidates parrot. It works, but a senior interviewer will probe its seams. Here's what we changed and why each change is interview-defensible.

Extension Points (Open / Closed)

Three things this design can absorb without editing the existing classes — which is exactly what Open/Closed promises.

Trade-offs & Talking Points

Every choice in the design beats one alternative — and brings its own cost. These are the trade-offs an interviewer will probe.

Interview Q & A

The follow-ups an interviewer almost always asks after the main design. Practice saying these out loud — they're the difference between "candidate knows the canonical answer" and "candidate has actually thought about this".