The LLD + Java Interview Rulebook

+----------------------------+
|       ClassName            |  <- Concrete Class
+----------------------------+
| - privateField: Type       |
| # protectedField: Type     |
| + publicField: Type        |
+----------------------------+
| + publicMethod(): ReturnType|
| - privateMethod(): void    |
| + staticMethod(): Type     |
+----------------------------+

<<interface>>
+----------------------------+
|       InterfaceName        |
+----------------------------+
| + method1(): void          |
| + method2(): String        |
+----------------------------+

<<abstract>>
+----------------------------+
|    AbstractClassName       |
+----------------------------+
| # sharedField: Type        |
+----------------------------+
| + concreteMethod(): void   |
| + abstractMethod(): void   |  <- italicize or mark (abstract)
+----------------------------+

Client          Controller                Service                Repository            External
  |                 |                        |                        |                    |
  |-- POST /api/v1/kyc ------------------->|                        |                    |
  |   (Create KYC Request)                |                        |                    |
  |                 |-- validate() ------>|                        |                    |
  |                 |                     |-- GET /kyc/{id} ------>|                    |
  |                 |                     |                        |-- query() -------->|
  |                 |                     |                        |<-- result ---------|
  |                 |                     |<-- entity -------------|                    |
  |                 |                     |-- GET /external/user/{id} ----------------->|
  |                 |                     |<---------------------- external data -------|
  |                 |                     |-- process()            |                    |
  |                 |                     |-- PUT /kyc/{id} ------>|                    |
  |                 |                     |                        |-- save() ----------|
  |                 |<-- response --------|                        |                    |
  |<-- 201 Created --|                    |                        |                    |

[alt: item found]
  Service --> Repository: findById()
  Repository --> Service: Item
[else: item not found]
  Service --> Client: throw ItemNotFoundException
[end]

[loop: for each item in cart]
  Service --> PricingService: calculatePrice(item)
[end]

/*
 * [Pattern/Principle]: Strategy Pattern
 * [Why]: So we can swap pricing algorithms at runtime
 *        without modifying OrderService.
 * [Principle]: OCP -- Open for extension, closed for modification.
 */

package com.example.service;

/**
 * What it does: Processes orders end to end.
 * Why it exists: Central coordination point -- keeps Controller thin.
 * Pattern: Follows SRP -- only order processing logic here.
 */
public class OrderService {

    // Fields -- explain why each exists
    private final PaymentStrategy paymentStrategy;   // Strategy pattern -- pluggable payment
    private final Map<String, Order> orderStore;     // ConcurrentHashMap for thread safety

    // Constructor injection -- DIP: depend on abstraction, not concrete class
    public OrderService(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
        this.orderStore = new ConcurrentHashMap<>();
    }

    public Order placeOrder(String userId, List<Item> items) {
        // Step 1: Validate inputs
        validateInput(userId, items);

        // Step 2: Build order (Builder pattern if complex)
        Order order = new Order(UUID.randomUUID().toString(), userId, items, OrderStatus.PENDING);

        // Step 3: Process payment
        paymentStrategy.pay(order.getTotalAmount());

        // Step 4: Persist
        orderStore.put(order.getId(), order);

        return order;
    }
}

public class Order {
    private final String id;          // immutable
    private final String userId;
    private List<Item> items;
    private OrderStatus status;       // mutable -- lifecycle changes
    private final LocalDateTime createdAt;

    // Constructor, getters, equals(), hashCode(), toString()
}

public enum OrderStatus {
    PENDING, CONFIRMED, PROCESSING, SHIPPED, DELIVERED, CANCELLED
}

/*
 * Capability contract -- any class that can process payments implements this.
 * Allows swapping Credit, UPI, Wallet without touching OrderService.
 */
public interface PaymentStrategy {
    void pay(double amount);
    String getPaymentMode();
}

/*
 * Abstract class -- all notification channels share senderId + timestamp logic.
 * Subclasses only implement the channel-specific send().
 */
public abstract class Notification {
    protected final String senderId;
    protected final LocalDateTime timestamp;

    protected Notification(String senderId) {
        this.senderId = senderId;
        this.timestamp = LocalDateTime.now();
    }

    // Common behavior
    public void log() {
        System.out.println("[" + timestamp + "] Notification from " + senderId);
    }

    // Subclasses must implement
    public abstract void send(String message);
}

// Base exception -- callers can catch at right granularity
public class AppException extends RuntimeException {
    private final String errorCode;
    public AppException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
}

public class ItemNotFoundException extends AppException {
    public ItemNotFoundException(String itemId) {
        super("ITEM_NOT_FOUND", "Item not found: " + itemId);
    }
}

public class InsufficientBalanceException extends AppException {
    public InsufficientBalanceException(double required, double available) {
        super("INSUFFICIENT_BALANCE",
              "Required: " + required + ", Available: " + available);
    }
}

public class InvalidStateException extends AppException {
    public InvalidStateException(String currentState, String operation) {
        super("INVALID_STATE",
              "Cannot perform " + operation + " in state: " + currentState);
    }
}

// CAS with AtomicInteger
AtomicInteger seatCount = new AtomicInteger(100);
boolean booked = seatCount.compareAndSet(currentVal, currentVal - 1);

// Synchronized critical section
public synchronized boolean bookSeat(String seatId) {
    if (!availableSeats.contains(seatId)) throw new SeatUnavailableException(seatId);
    availableSeats.remove(seatId);
    bookedSeats.put(seatId, userId);
    return true;
}

// ReentrantLock for fine-grained control
private final ReentrantLock lock = new ReentrantLock();

public void transfer(Account from, Account to, double amount) {
    lock.lock();
    try {
        from.debit(amount);
        to.credit(amount);
    } finally {
        lock.unlock();   // always in finally
    }
}

// Idempotency check
private final Set<String> processedRequestIds = ConcurrentHashMap.newKeySet();

public void process(String requestId, Order order) {
    if (!processedRequestIds.add(requestId)) {
        return;  // duplicate -- already processed
    }
    // actual processing
}

public interface OrderState {
    void confirm(OrderContext ctx);
    void ship(OrderContext ctx);
    void cancel(OrderContext ctx);
}

public class PendingState implements OrderState {
    public void confirm(OrderContext ctx) {
        ctx.setState(new ConfirmedState());
    }
    public void ship(OrderContext ctx) {
        throw new InvalidStateException("PENDING", "ship");
    }
    public void cancel(OrderContext ctx) {
        ctx.setState(new CancelledState());
    }
}

public class OrderContext {
    private OrderState currentState = new PendingState();

    public void setState(OrderState state) { this.currentState = state; }
    public void confirm() { currentState.confirm(this); }
    public void ship()    { currentState.ship(this); }
    public void cancel()  { currentState.cancel(this); }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    public Order placeOrder(String userId, List<Item> items) {
        String requestId = UUID.randomUUID().toString();
        log.info("PlaceOrder started | requestId={} userId={} itemCount={}",
                 requestId, userId, items.size());

        try {
            // ... logic ...
            log.info("PlaceOrder success | requestId={} orderId={}", requestId, order.getId());
            return order;
        } catch (AppException e) {
            log.error("PlaceOrder failed | requestId={} errorCode={} reason={}",
                      requestId, e.getErrorCode(), e.getMessage());
            throw e;
        }
        // NO: log.info("Card number: " + card.getNumber());  <- never log sensitive data
    }
}