Beginner

// => This method handles THREE distinct responsibilities at once:
// => 1. Data access (reading from a map)
// => 2. Business logic (computing discount)
// => 3. Presentation (formatting a string for display)
import java.util.Map;
 
public class CoupledExample {
    public static String getUserDiscountMessage(int userId) {
        // => userDb simulates a database lookup — data access concern
        Map<Integer, Map<String, Object>> userDb = Map.of(
            1, Map.of("name", "Alice", "purchases", 12)
        );
        // => user is {"name": "Alice", "purchases": 12}
        Map<String, Object> user = userDb.get(userId);
        // => Business rule embedded directly here — hard to change independently
        double discount = ((int) user.get("purchases") > 10) ? 0.15 : 0.05;
        // => discount is 0.15 (15%) because purchases > 10
        // => Presentation formatted inline — impossible to reuse discount logic elsewhere
        return String.format("Hello %s, your discount is %.0f%%", user.get("name"), discount * 100);
        // => Output: "Hello Alice, your discount is 15%"
    }
}

// => DATA ACCESS — only knows how to retrieve users
import java.util.Map;
 
public class SeparatedExample {
    private static final Map<Integer, Map<String, Object>> USER_DB =
        Map.of(1, Map.of("name", "Alice", "purchases", 12));
 
    static Map<String, Object> findUser(int userId) {
        return USER_DB.get(userId);   // => returns user map or null
    }
 
    // => BUSINESS LOGIC — only knows discount rules, not storage or display
    static double calculateDiscount(int purchases) {
        if (purchases > 10) return 0.15;   // => 15% for loyal customers (>10 purchases)
        return 0.05;                        // => 5% default discount
    }
 
    // => PRESENTATION — only knows how to format, not how to compute or fetch
    static String formatDiscountMessage(String name, double discount) {
        return String.format("Hello %s, your discount is %.0f%%", name, discount * 100);
        // => Output: "Hello Alice, your discount is 15%"
    }
 
    // => ORCHESTRATION — thin coordinator that wires the three layers together
    public static String getUserDiscountMessage(int userId) {
        Map<String, Object> user = findUser(userId);      // => delegates data access
        double discount = calculateDiscount((int) user.get("purchases")); // => delegates business rule
        return formatDiscountMessage((String) user.get("name"), discount); // => delegates formatting
    }
 
    public static void main(String[] args) {
        System.out.println(getUserDiscountMessage(1));
        // => Output: Hello Alice, your discount is 15%
    }
}

// => UserManager handles user data AND email sending AND password logic
// => This class has THREE reasons to change: user schema, email templates, auth rules
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
 
public class UserManager {
    private final Map<Integer, Map<String, String>> users = new HashMap<>();
    // => users stores id → { "name": ..., "email": ... }
 
    public void addUser(int id, String name, String email) {
        users.put(id, Map.of("name", name, "email", email));
        // => stores user under id key
    }
 
    // => EMAIL CONCERN embedded in user class — mixing responsibilities
    public void sendWelcomeEmail(int userId) {
        Map<String, String> user = users.get(userId); // => retrieves user or null
        if (user != null) {
            System.out.println("Sending email to " + user.get("email") + ": Welcome, " + user.get("name") + "!");
            // => Output: Sending email to alice@example.com: Welcome, Alice!
        }
    }
 
    // => PASSWORD CONCERN also embedded — a third responsibility
    public String resetPassword(int userId) {
        String newPassword = UUID.randomUUID().toString().substring(0, 8);
        // => newPassword is a random 8-char string like "a3f9c2b1"
        System.out.println("Password reset for user " + userId + ": " + newPassword);
        return newPassword; // => returns the new password string
    }
}

// => RESPONSIBILITY 1: User data management only
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
 
class UserRepository {
    private final Map<Integer, Map<String, String>> users = new HashMap<>();
 
    public void add(int id, String name, String email) {
        users.put(id, Map.of("name", name, "email", email));
        // => stores user record under id key
    }
 
    public Map<String, String> get(int id) {
        return users.get(id); // => returns user map or null
    }
}
 
// => RESPONSIBILITY 2: Email notifications only
class EmailService {
    public void sendWelcome(String name, String email) {
        System.out.println("Sending email to " + email + ": Welcome, " + name + "!");
        // => Output: Sending email to alice@example.com: Welcome, Alice!
    }
}
 
// => RESPONSIBILITY 3: Password management only
class PasswordService {
    public String reset(int userId) {
        String newPassword = UUID.randomUUID().toString().substring(0, 8);
        // => newPassword is a random 8-char string
        System.out.println("Password reset for user " + userId + ": " + newPassword);
        return newPassword; // => returns the generated password
    }
}

// ============================================================
// DATA ACCESS LAYER — only knows about storage
// ============================================================
import java.util.Map;
import java.util.Optional;
 
record Product(int id, String name, double price, int stock) {}
 
class ProductRepository {
    // => in-memory store simulating a database table
    private final Map<Integer, Product> products = Map.of(
        1, new Product(1, "Laptop", 1200.0, 5),
        2, new Product(2, "Mouse",  25.0,   0)
    );
 
    Optional<Product> findById(int productId) {
        return Optional.ofNullable(products.get(productId));
        // => returns Optional.of(product) or Optional.empty()
    }
}
 
// ============================================================
// BUSINESS LOGIC LAYER — only knows about rules
// ============================================================
class ProductService {
    private final ProductRepository repo;
    // => repo is injected, not created here (dependency injection)
 
    ProductService(ProductRepository repo) { this.repo = repo; }
 
    Product getAvailableProduct(int productId) {
        Product product = repo.findById(productId)
            .orElseThrow(() -> new IllegalArgumentException("Product " + productId + " not found"));
        // => throws if not found — presentation layer will catch this
        if (product.stock() == 0) {
            throw new IllegalStateException("Product '" + product.name() + "' is out of stock");
            // => business rule: zero stock means unavailable
        }
        return product; // => returns valid product
    }
}
 
// ============================================================
// PRESENTATION LAYER — only knows about formatting responses
// ============================================================
class ProductController {
    static String handleGetProduct(int productId) {
        ProductRepository repo = new ProductRepository();  // => creates data layer
        ProductService service = new ProductService(repo); // => creates business layer, injects repo
        try {
            Product p = service.getAvailableProduct(productId);
            // => delegates all business logic to service
            return String.format("Available: %s at $%.2f", p.name(), p.price());
            // => Output (id=1): "Available: Laptop at $1200.00"
        } catch (Exception e) {
            return "Error: " + e.getMessage();
            // => Output (id=2): "Error: Product 'Mouse' is out of stock"
        }
    }
 
    public static void main(String[] args) {
        System.out.println(handleGetProduct(1)); // => Available: Laptop at $1200.00
        System.out.println(handleGetProduct(2)); // => Error: Product 'Mouse' is out of stock
    }
}

// => DATA LAYER — retrieves raw records
import java.util.Map;
import java.util.Optional;
 
record Order(int id, double total, String status) {}
 
class OrderRepository {
    // => orderDb simulates a database table with two records
    private static final Map<Integer, Order> ORDER_DB = Map.of(
        101, new Order(101, 299.99, "shipped"),
        102, new Order(102, 49.0,  "pending")
    );
 
    static Optional<Order> findOrder(int id) {
        return Optional.ofNullable(ORDER_DB.get(id));
        // => returns Optional.of(order) or Optional.empty()
    }
}
 
// => BUSINESS LAYER — applies domain rules
class OrderRules {
    static boolean isEligibleForCancellation(Order order) {
        return order.status().equals("pending") && order.total() < 500;
        // => true only when pending AND total below cancellation threshold
    }
}
 
// => PRESENTATION LAYER — translates, never decides
class OrderController {
    static String handleCancelRequest(int orderId) {
        Optional<Order> maybeOrder = OrderRepository.findOrder(orderId);
        // => fetches from data layer
        if (maybeOrder.isEmpty()) {
            return "Order " + orderId + " not found";
            // => presentation transforms absence to user-readable message
        }
        Order order = maybeOrder.get();
        boolean eligible = OrderRules.isEligibleForCancellation(order);
        // => business logic evaluated in business layer, result consumed here
        if (eligible) {
            return "Order " + orderId + " cancelled successfully";
            // => Output (id=102): "Order 102 cancelled successfully"
        }
        return "Order " + orderId + " cannot be cancelled (status: " + order.status() + ")";
        // => Output (id=101): "Order 101 cannot be cancelled (status: shipped)"
    }
 
    public static void main(String[] args) {
        System.out.println(handleCancelRequest(101)); // => Order 101 cannot be cancelled (status: shipped)
        System.out.println(handleCancelRequest(102)); // => Order 102 cancelled successfully
        System.out.println(handleCancelRequest(999)); // => Order 999 not found
    }
}

// ============================================================
// MODEL — data container + business validation
// ============================================================
import java.util.ArrayList;
import java.util.List;
 
class TodoModel {
    record TodoItem(int id, String title, boolean done) {
        TodoItem withDone() { return new TodoItem(id, title, true); }
        // => creates a new record with done=true (records are immutable)
    }
 
    private final List<TodoItem> items = new ArrayList<>();
    // => internal list of todo items
    private int nextId = 1;
    // => auto-incrementing id counter
 
    TodoItem add(String title) {
        TodoItem item = new TodoItem(nextId++, title, false);
        // => item is TodoItem(id=1, title="Buy milk", done=false)
        items.add(item);   // => appended to internal list
        return item;       // => returns the created item
    }
 
    List<TodoItem> getAll() {
        return List.copyOf(items); // => returns unmodifiable copy to prevent mutation
    }
 
    boolean complete(int itemId) {
        for (int i = 0; i < items.size(); i++) {
            if (items.get(i).id() == itemId) {
                items.set(i, items.get(i).withDone()); // => replaces with done=true copy
                return true;   // => returns true = success
            }
        }
        return false; // => returns false = item not found
    }
}
 
// ============================================================
// VIEW — formats data for display, no logic
// ============================================================
class TodoView {
    String renderList(List<TodoModel.TodoItem> items) {
        if (items.isEmpty()) return "No todos yet.";
        // => Output when empty list
        StringBuilder sb = new StringBuilder();
        for (TodoModel.TodoItem item : items) {
            String status = item.done() ? "✓" : "○";
            // => status is "✓" for done items, "○" for pending
            sb.append("[").append(status).append("] ")
              .append(item.id()).append(". ").append(item.title()).append("\n");
        }
        return sb.toString().trim(); // => joined with newlines
    }
 
    String renderCreated(TodoModel.TodoItem item) {
        return "Created todo #" + item.id() + ": " + item.title();
        // => Output: "Created todo #1: Buy milk"
    }
}
 
// ============================================================
// CONTROLLER — coordinates model and view
// ============================================================
class TodoController {
    private final TodoModel model; // => stores model reference
    private final TodoView view;   // => stores view reference
 
    TodoController(TodoModel model, TodoView view) {
        this.model = model;
        this.view  = view;
    }
 
    String create(String title) {
        TodoModel.TodoItem item = model.add(title); // => delegates creation to model
        return view.renderCreated(item);             // => delegates formatting to view
    }
 
    String listAll() {
        return view.renderList(model.getAll());
        // => fetches all items from model, delegates rendering to view
    }
 
    String done(int itemId) {
        boolean success = model.complete(itemId); // => delegates completion to model
        return success ? "Todo #" + itemId + " marked as done"
                       : "Todo #" + itemId + " not found";
    }
 
    public static void main(String[] args) {
        // => Wire the MVC triad together
        TodoModel model = new TodoModel();
        TodoView  view  = new TodoView();
        TodoController controller = new TodoController(model, view);
 
        System.out.println(controller.create("Buy milk"));    // => Created todo #1: Buy milk
        System.out.println(controller.create("Write tests")); // => Created todo #2: Write tests
        System.out.println(controller.done(1));               // => Todo #1 marked as done
        System.out.println(controller.listAll());
        // => [✓] 1. Buy milk
        // => [○] 2. Write tests
    }
}

// => MODEL with self-contained validation — the model is the single source of truth
public class BankAccount {
    private double balance;               // => private: external code cannot bypass validation
    private static final double MINIMUM_BALANCE = 0; // => business rule: no overdrafts
 
    public BankAccount(double initialBalance) {
        if (initialBalance < 0) {
            throw new IllegalArgumentException("Initial balance cannot be negative");
            // => enforced at construction time, not by the caller
        }
        this.balance = initialBalance; // => balance is initialBalance (e.g., 100)
    }
 
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit amount must be positive");
            // => model rejects invalid inputs without controller involvement
        }
        balance += amount; // => balance increases by amount
    }
 
    public void withdraw(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Withdrawal amount must be positive");
        // => reject non-positive withdrawal at the gate
        if (balance - amount < MINIMUM_BALANCE) {
            throw new IllegalStateException("Insufficient funds: balance is " + balance);
            // => business rule enforced in model, not leaked to controller
        }
        balance -= amount; // => balance decreases by amount
    }
 
    public double getBalance() { return balance; }
    // => read-only access to private state
 
    // => CONTROLLER — delegates entirely to model, no duplicate validation
    static String handleWithdraw(BankAccount account, double amount) {
        try {
            account.withdraw(amount); // => model enforces all rules
            return "Withdrawal successful. Balance: $" + account.getBalance();
            // => Output: "Withdrawal successful. Balance: $50.0"
        } catch (Exception e) {
            return "Withdrawal failed: " + e.getMessage();
            // => Output: "Withdrawal failed: Insufficient funds: balance is 50.0"
        }
    }
 
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100); // => account.balance is 100
        System.out.println(handleWithdraw(account, 50));  // => Withdrawal successful. Balance: $50.0
        System.out.println(handleWithdraw(account, 200)); // => Withdrawal failed: Insufficient funds: balance is 50.0
    }
}

// => UserService creates its own database connection — cannot be tested without real DB
import java.util.Map;
 
class HardcodedUserService {
    // => hardcoded dependency: impossible to substitute a fake in tests
    private final Map<Integer, String> db = Map.of(1, "Alice", 2, "Bob");
 
    String getName(int userId) {
        return db.get(userId); // => returns name or null — no DI, no seam for testing
    }
}

// => INTERFACE defines what UserService needs from storage
import java.util.Map;
 
interface UserStore {
    String fetch(int userId);
    // => any class implementing fetch(int) -> String satisfies this contract
}
 
// => REAL implementation for production
class DictUserStore implements UserStore {
    private final Map<Integer, String> data = Map.of(1, "Alice", 2, "Bob");
    // => simulates a real DB
 
    @Override
    public String fetch(int userId) {
        return data.get(userId); // => returns name or null
    }
}
 
// => FAKE implementation for tests — no DB required
class FakeUserStore implements UserStore {
    @Override
    public String fetch(int userId) {
        return "TestUser"; // => always returns a fixed value for testing
    }
}
 
// => SERVICE accepts any UserStore — decoupled from specific implementation
class UserService {
    private final UserStore store;
    // => store is injected, not created here
 
    UserService(UserStore store) { this.store = store; }
    // => store assigned from outside — caller decides which implementation
 
    String greet(int userId) {
        String name = store.fetch(userId); // => delegates to whatever store was injected
        if (name == null) return "User " + userId + " not found";
        return "Hello, " + name + "!";    // => Output: "Hello, Alice!"
    }
 
    public static void main(String[] args) {
        // => PRODUCTION: inject real store
        UserService service = new UserService(new DictUserStore());
        System.out.println(service.greet(1));  // => Hello, Alice!
        System.out.println(service.greet(99)); // => User 99 not found
 
        // => TEST: inject fake store — no database needed
        UserService testService = new UserService(new FakeUserStore());
        System.out.println(testService.greet(1)); // => Hello, TestUser!
    }
}

// => CONSTRUCTOR INJECTION — dependency lives for the object's lifetime
// => Use when: dependency is always required and does not change per call
import java.util.function.IntPredicate;
 
interface PaymentGateway {
    boolean charge(int amount); // => contract: charge(amount) -> approved or declined
}
 
class OrderProcessor {
    private final PaymentGateway paymentGateway;
    // => paymentGateway is stored for the lifetime of OrderProcessor
 
    OrderProcessor(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway; // => injected at construction time
        // => caller decides which gateway is used — OrderProcessor is gateway-agnostic
    }
 
    String processOrder(int orderId, int amount) {
        boolean success = paymentGateway.charge(amount);
        // => delegates to whatever gateway was injected at construction
        return success
            ? "Order " + orderId + " paid ($" + amount + ")"
            : "Order " + orderId + " payment failed";
        // => Output (amount=500):  "Order 1 paid ($500)"
        // => Output (amount=1500): "Order 2 payment failed"
    }
}
 
// => METHOD INJECTION — dependency passed per call
// => Use when: dependency varies per request (e.g., per-user logger, per-request context)
interface Output {
    void write(String msg); // => contract: write(msg) — caller supplies the sink
}
 
class AuditLogger {
    void log(String message, Output output) {
        // => output is injected per call — can be console, file, or database
        output.write("[AUDIT] " + message);
        // => delegates writing to whatever Output was passed in
    }
}
 
public class InjectionExample {
    public static void main(String[] args) {
        // => CONSTRUCTOR INJECTION: gateway wired once at composition root
        PaymentGateway fakeGateway = amount -> amount < 1000;
        // => fakeGateway approves amounts below 1000 (simulates approval limit)
        OrderProcessor processor = new OrderProcessor(fakeGateway);
        System.out.println(processor.processOrder(1, 500));  // => Order 1 paid ($500)
        System.out.println(processor.processOrder(2, 1500)); // => Order 2 payment failed
 
        // => METHOD INJECTION: output sink supplied per call
        AuditLogger logger = new AuditLogger();
        logger.log("User login", msg -> System.out.println(msg));
        // => Output: [AUDIT] User login
        logger.log("File export", msg -> System.out.println(">> " + msg));
        // => Output: >> [AUDIT] File export
    }
}

// => FAT interface: all implementors must provide ALL four methods
// => even when most methods are irrelevant to that implementor
interface EmployeeOperations {
    double calculateSalary();       // => relevant for paid employees
    void clockIn();                 // => relevant for hourly workers
    String generateReport();        // => relevant for managers
    void requestLeave(int days);    // => relevant for all employees
}
 
// => CONTRACTOR only needs salary, yet must implement the other three
class Contractor implements EmployeeOperations {
    @Override public double calculateSalary() { return 500; }
    // => useful — flat daily rate
 
    @Override public void clockIn() { /* not applicable */ }
    // => forced but meaningless — contractors don't clock in
 
    @Override public String generateReport() { return ""; }
    // => forced but meaningless — contractors don't generate reports
 
    @Override public void requestLeave(int days) {}
    // => forced but meaningless — contractors don't use this leave system
}

// => FOCUSED interfaces: each covers exactly one capability
interface Payable      { double calculateSalary(); }       // => pay calculation only
interface Trackable    { void clockIn(); }                  // => time tracking only
interface Reportable   { String generateReport(); }         // => reporting only
interface LeaveEligible { void requestLeave(int days); }   // => leave management only
 
// => CONTRACTOR: only salary matters — no forced empty methods
class SegregatedContractor implements Payable {
    @Override
    public double calculateSalary() { return 500; }
    // => flat daily rate — no other obligations
}
 
// => FULL-TIME EMPLOYEE: salary + time tracking + leave
class FullTimeEmployee implements Payable, Trackable, LeaveEligible {
    private int hoursWorked = 0; // => tracks hours for this period
 
    @Override
    public double calculateSalary() { return hoursWorked * 25; }
    // => $25/hour rate applied to tracked hours
 
    @Override
    public void clockIn() { hoursWorked += 8; }
    // => adds one full work day (8 hours)
 
    @Override
    public void requestLeave(int days) {
        System.out.println("Leave requested: " + days + " day(s)");
        // => Output: Leave requested: 5 day(s)
    }
}
 
// => MANAGER: salary + reporting — no clock-in, no leave tracked here
class Manager implements Payable, Reportable {
    @Override public double calculateSalary() { return 8000; }
    // => fixed monthly salary
 
    @Override
    public String generateReport() { return "Team performance: on track"; }
    // => manager-specific report string
}
 
public class ISPExample {
    public static void main(String[] args) {
        SegregatedContractor contractor = new SegregatedContractor();
        System.out.println(contractor.calculateSalary()); // => 500.0
 
        FullTimeEmployee emp = new FullTimeEmployee();
        emp.clockIn();                               // => hoursWorked is now 8
        System.out.println(emp.calculateSalary());   // => 200.0 (8 * 25)
    }
}

// => VIOLATION: adding a new discount type requires editing this method
// => Every new case expands this if-else chain — "open for modification" anti-pattern
public class ClosedViolation {
    static double calculateDiscount(double price, String discountType) {
        if (discountType.equals("regular")) {
            return price * 0.10;  // => 10% off
        } else if (discountType.equals("loyalty")) {
            return price * 0.20;  // => 20% off for loyal customers
        }
        // => Every new discount type forces an edit here — risky regression surface
        return 0.0;
    }
}

// => ABSTRACT BASE — defines the contract, never changes
abstract class DiscountStrategy {
    abstract double calculate(double price);
    // => all strategies must implement calculate(price) -> double
}
 
// => CONCRETE STRATEGIES — add new ones without touching existing code
class RegularDiscount extends DiscountStrategy {
    @Override
    double calculate(double price) { return price * 0.10; }
    // => 10% discount
}
 
class LoyaltyDiscount extends DiscountStrategy {
    @Override
    double calculate(double price) { return price * 0.20; }
    // => 20% discount for loyal customers
}
 
// => EXTENSION: new discount type — existing code is UNTOUCHED
class SeasonalDiscount extends DiscountStrategy {
    @Override
    double calculate(double price) { return price * 0.30; }
    // => 30% seasonal sale discount — added without modifying existing classes
}
 
// => CLIENT: depends on the abstract base, not concrete classes
class PriceCalculator {
    private final DiscountStrategy strategy;
    // => strategy is injected — PriceCalculator never changes when new discounts arrive
 
    PriceCalculator(DiscountStrategy strategy) {
        this.strategy = strategy; // => stores injected strategy
    }
 
    double finalPrice(double price) {
        double discount = strategy.calculate(price);
        // => delegates discount computation to injected strategy
        return price - discount; // => price minus discount amount
    }
 
    public static void main(String[] args) {
        PriceCalculator calc = new PriceCalculator(new RegularDiscount());
        System.out.println(calc.finalPrice(100.0));  // => 90.0 (100 - 10)
 
        PriceCalculator calc2 = new PriceCalculator(new SeasonalDiscount());
        System.out.println(calc2.finalPrice(100.0)); // => 70.0 (100 - 30)
    }
}

// => BASE CLASS: Rectangle assumes width and height are independent
class Rectangle {
    protected int width;
    protected int height;
 
    Rectangle(int width, int height) {
        this.width  = width;  // => width is set independently
        this.height = height; // => height is set independently
    }
 
    void setWidth(int w)  { this.width  = w; } // => changes ONLY width
    void setHeight(int h) { this.height = h; } // => changes ONLY height
 
    int area() { return width * height; } // => width * height
}
 
// => SQUARE forces both dimensions equal — violates Rectangle's contract
class Square extends Rectangle {
    Square(int side) { super(side, side); }
 
    @Override
    void setWidth(int w) {
        this.width  = w; // => changes width
        this.height = w; // => ALSO changes height — breaks Rectangle's contract
    }
 
    @Override
    void setHeight(int h) {
        this.height = h; // => changes height
        this.width  = h; // => ALSO changes width — breaks Rectangle's contract
    }
}
 
// => CALLER written for Rectangle — breaks silently when given Square
static void testRectangle(Rectangle r) {
    r.setWidth(5);
    r.setHeight(3);
    // => For Rectangle: area is 5 * 3 = 15 (expected)
    // => For Square:    area is 3 * 3 = 9  (unexpected — LSP violated)
    System.out.println("Area: " + r.area());
}
 
public static void main(String[] args) {
    testRectangle(new Rectangle(1, 1)); // => Area: 15 (correct)
    testRectangle(new Square(1));       // => Area: 9  (violates LSP)
}

// => SHAPE interface: defines area() contract without assuming dimension independence
interface Shape { int area(); }
 
// => RECTANGLE: independent width and height — no coupling to Square behavior
class ProperRectangle implements Shape {
    private final int width;
    private final int height;
 
    ProperRectangle(int width, int height) {
        this.width  = width;  // => width stored independently
        this.height = height; // => height stored independently
    }
 
    @Override
    public int area() { return width * height; }
    // => width * height — always correct for any width/height pair
}
 
// => SQUARE: single side length, no inherited width/height confusion
class ProperSquare implements Shape {
    private final int side;
    // => only one dimension: side — square invariant enforced by design
 
    ProperSquare(int side) { this.side = side; }
 
    @Override
    public int area() { return side * side; }
    // => side * side — always correct
}
 
// => CALLER: works for any Shape — LSP satisfied
static void printArea(Shape shape) {
    System.out.println("Area: " + shape.area());
}
 
public static void main(String[] args) {
    printArea(new ProperRectangle(5, 3)); // => Area: 15
    printArea(new ProperSquare(4));       // => Area: 16
}

// => VIOLATION: the "eligible user" rule is duplicated in every method
// => If the rule changes (e.g., add emailVerified check), all three must be updated
import java.util.Map;
 
public class DryViolation {
    static void sendNotification(Map<String, Object> user) {
        if ((boolean) user.get("active") && (int) user.get("age") >= 18) {
            // => rule duplicated here — must be changed in all three places if rule evolves
            System.out.println("Notifying " + user.get("name"));
        }
    }
 
    static void generateReport(Map<String, Object> user) {
        if ((boolean) user.get("active") && (int) user.get("age") >= 18) {
            // => same rule repeated — divergence risk if one copy is missed
            System.out.println("Report for " + user.get("name"));
        }
    }
 
    static boolean allowPurchase(Map<String, Object> user) {
        if ((boolean) user.get("active") && (int) user.get("age") >= 18) {
            // => rule duplicated a third time
            return true;
        }
        return false;
    }
}

// => SINGLE SOURCE OF TRUTH: eligibility rule defined once
import java.util.Map;
 
public class DryCompliant {
    // => isEligibleUser is the one and only definition of the business rule
    static boolean isEligibleUser(Map<String, Object> user) {
        return (boolean) user.get("active") && (int) user.get("age") >= 18;
        // => returns true only if active AND adult
        // => changing this rule updates all three callers automatically
    }
 
    static void sendNotification(Map<String, Object> user) {
        if (isEligibleUser(user)) { // => delegates to single rule
            System.out.println("Notifying " + user.get("name"));
            // => Output: Notifying Alice
        }
    }
 
    static void generateReport(Map<String, Object> user) {
        if (isEligibleUser(user)) { // => same single rule — no duplication
            System.out.println("Report for " + user.get("name"));
        }
    }
 
    static boolean allowPurchase(Map<String, Object> user) {
        return isEligibleUser(user); // => single rule, zero duplication
    }
 
    public static void main(String[] args) {
        Map<String, Object> user = Map.of("name", "Alice", "active", true, "age", 25);
        sendNotification(user);                       // => Notifying Alice
        System.out.println(allowPurchase(user));      // => true
    }
}

// => OVER-ENGINEERED: factory + strategy + builder for a simple greeting
// => Five classes to accomplish what one method can do
interface GreetingStrategy {
    String greet(String name); // => contract for producing a greeting string
}
 
class FormalGreetingStrategy implements GreetingStrategy {
    @Override
    public String greet(String name) {
        return "Good day, " + name + "."; // => produces formal greeting
    }
}
 
class GreetingFactory {
    // => factory adds a layer of indirection over strategy instantiation
    static GreetingStrategy create(String type) {
        if (type.equals("formal")) return new FormalGreetingStrategy();
        throw new IllegalArgumentException("Unknown greeting type: " + type);
        // => throws for any type other than "formal" — fragile extension point
    }
}
 
class GreetingBuilder {
    private String type = "formal"; // => default type
 
    GreetingBuilder withType(String type) {
        this.type = type; // => allows chaining: new GreetingBuilder().withType("formal")
        return this;       // => returns this for fluent API
    }
 
    GreetingStrategy build() {
        return GreetingFactory.create(type);
        // => delegates to factory — extra hop with no added value here
    }
}
 
public class KissViolation {
    public static void main(String[] args) {
        // => 4 collaborating classes just to print one greeting line
        String greeting = new GreetingBuilder().withType("formal").build().greet("Alice");
        System.out.println(greeting); // => Good day, Alice.
    }
}

// => SIMPLE: one method, zero ceremony, achieves the same result
// => No interface, no factory, no builder — plain static method
public class KissCompliant {
    static String greet(String name) {
        return "Good day, " + name + ".";
        // => Output: Good day, Alice.
        // => If greeting types are needed later, add them then (YAGNI)
    }
 
    public static void main(String[] args) {
        System.out.println(greet("Alice")); // => Good day, Alice.
    }
}

// => YAGNI VIOLATION: speculative features not required by any current use case
public class UserProfile {
    private final String name;   // => required today
    private final String email;  // => required today
 
    // => SPECULATIVE: no current feature requires these fields
    private String theme = "light";                // => "might need dark mode someday"
    private String preferredLanguage = "en";       // => "maybe we'll go international"
    private String newsletterFrequency = "weekly"; // => "for a newsletter we haven't built"
    private boolean aiRecommendations = true;      // => "for an AI feature in the roadmap"
 
    public UserProfile(String name, String email) {
        this.name  = name;
        this.email = email;
    }
 
    // => SPECULATIVE: no current caller uses this — dead code increasing maintenance burden
    public String exportToXml() {
        return "<user><name>" + name + "</name></user>";
        // => XML export for a feature that hasn't been requested yet
    }
 
    // => SPECULATIVE: no current caller needs analytics integration
    public void trackEngagement(String event) {
        System.out.println("[Analytics] " + name + ": " + event);
        // => analytics hook for a system that doesn't exist yet
    }
}
 
// => YAGNI COMPLIANT: only what the application actually needs right now
class SimpleUserProfile {
    private final String name;   // => required today
    private final String email;  // => required today
    // => No speculative fields — add when a feature actually needs them
 
    SimpleUserProfile(String name, String email) {
        this.name  = name;
        this.email = email;
    }
 
    String displayName() {
        return name; // => required today for display
        // => Output: "Alice"
    }
 
    public static void main(String[] args) {
        SimpleUserProfile user = new SimpleUserProfile("Alice", "alice@example.com");
        System.out.println(user.displayName()); // => Alice
        // => Add exportToXml() when an export feature is actually built
        // => Add theme field when a dark mode feature is actually shipped
    }
}

// => HIGH COUPLING: OrderService reaches into the internals of Customer and Inventory
import java.util.HashMap;
import java.util.Map;
 
class Customer {
    // => public fields expose internals — any caller can read or mutate them
    public String name;
    public double creditLimit;   // => exposed internal detail
    public double outstandingBalance = 0.0; // => mutable state visible to all
    public Customer(String name, double creditLimit) {
        this.name = name;
        this.creditLimit = creditLimit; // => set at construction
    }
}
 
class Inventory {
    // => public map exposes backing data structure — callers can manipulate it directly
    public Map<String, Integer> items = new HashMap<>();
    public Inventory() {
        items.put("Laptop", 5); // => raw map exposed to all callers
    }
}
 
// => OrderService KNOWS about Customer's internals AND Inventory's internals
class TightlyCoupledOrderService {
    public String placeOrder(Customer customer, Inventory inventory, String item, double price) {
        // => directly reads customer's internal fields — tight coupling
        if (customer.outstandingBalance + price > customer.creditLimit) {
            return "Credit limit exceeded"; // => caller must know field names
        }
        // => directly reads inventory's internal map — tight coupling
        if (inventory.items.getOrDefault(item, 0) <= 0) {
            return item + " is out of stock"; // => coupled to Map implementation
        }
        customer.outstandingBalance += price; // => mutates customer state directly
        inventory.items.put(item, inventory.items.get(item) - 1); // => mutates inventory state
        return "Order placed: " + item + " for " + customer.name;
        // => Output: "Order placed: Laptop for Alice"
        // => If Customer renames creditLimit, this line breaks
        // => If Inventory switches to a database, this line breaks
    }
 
    public static void main(String[] args) {
        Customer customer = new Customer("Alice", 2000.0);
        Inventory inventory = new Inventory();
        TightlyCoupledOrderService service = new TightlyCoupledOrderService();
        System.out.println(service.placeOrder(customer, inventory, "Laptop", 1200.0));
        // => Order placed: Laptop for Alice
    }
}

// => ENCAPSULATED Customer — hides internals behind stable methods
import java.util.HashMap;
import java.util.Map;
 
class EncapsulatedCustomer {
    private final String name;
    private final double creditLimit;
    private double balance = 0.0; // => private: external code cannot touch directly
 
    public EncapsulatedCustomer(String name, double creditLimit) {
        this.name = name;
        this.creditLimit = creditLimit; // => stored privately
    }
 
    public String getName() { return name; } // => read-only access to name
 
    public boolean canAcceptCharge(double amount) {
        return balance + amount <= creditLimit;
        // => hides the credit formula — callers don't know the field names
    }
 
    public void recordCharge(double amount) {
        balance += amount; // => only method that mutates balance
        // => internal representation can change without affecting callers
    }
}
 
// => ENCAPSULATED Inventory — hides the backing data structure
class EncapsulatedInventory {
    private final Map<String, Integer> stock = new HashMap<>();
    // => private backing map
 
    public EncapsulatedInventory() {
        stock.put("Laptop", 5); // => initialized privately
    }
 
    public boolean isAvailable(String item) {
        return stock.getOrDefault(item, 0) > 0;
        // => hides how stock is stored — could be a database call tomorrow
    }
 
    public void decrement(String item) {
        stock.computeIfPresent(item, (k, v) -> v > 0 ? v - 1 : v);
        // => only method that mutates stock — controlled access
    }
}
 
// => LOOSELY COUPLED OrderService — talks only through public interfaces
class LooselyCoupldeOrderService {
    public String placeOrder(EncapsulatedCustomer customer,
                              EncapsulatedInventory inventory,
                              String item, double price) {
        if (!customer.canAcceptCharge(price)) {
            return "Credit limit exceeded"; // => no internal field access
        }
        if (!inventory.isAvailable(item)) {
            return item + " is out of stock"; // => no map access
        }
        customer.recordCharge(price);   // => delegates mutation to owner
        inventory.decrement(item);      // => delegates mutation to owner
        return "Order placed: " + item + " for " + customer.getName();
        // => Output: "Order placed: Laptop for Alice"
        // => Renaming private fields has ZERO impact on this service
    }
 
    public static void main(String[] args) {
        EncapsulatedCustomer customer = new EncapsulatedCustomer("Alice", 2000.0);
        EncapsulatedInventory inventory = new EncapsulatedInventory();
        LooselyCoupldeOrderService service = new LooselyCoupldeOrderService();
        System.out.println(service.placeOrder(customer, inventory, "Laptop", 1200.0));
        // => Order placed: Laptop for Alice
    }
}

// => LOW COHESION: MixedUtilities handles three completely unrelated domains
import java.time.LocalDate;
 
class MixedUtilities {
    // => string manipulation
    public String formatTitle(String title) {
        return title.toUpperCase(); // => "hello" → "HELLO"
    }
 
    // => financial calculation — unrelated to strings
    public double calculateTax(double price, double rate) {
        return price * rate; // => 100 * 0.1 = 10.0
    }
 
    // => date manipulation — unrelated to both of the above
    public String getDayOfWeek(LocalDate date) {
        return date.getDayOfWeek().name();
        // => "MONDAY", "TUESDAY", etc.
    }
}

// => HIGH COHESION: each class groups only related behavior
// => REASON: when formatTitle changes, it does not affect tax or date logic
import java.time.LocalDate;
 
class StringFormatter {
    // => All methods relate to text formatting
    public String formatTitle(String title) {
        return title.toUpperCase(); // => "hello" → "HELLO"
    }
 
    public String truncate(String text, int maxLength) {
        return text.length() > maxLength ? text.substring(0, maxLength) + "…" : text;
        // => "Hello World" with maxLength=5 → "Hello…"
    }
}
 
class TaxCalculator {
    // => All methods relate to tax computation
    public double calculate(double price, double rate) {
        return price * rate; // => 100 * 0.1 = 10.0
    }
 
    public double calculateWithCap(double price, double rate, double cap) {
        double tax = price * rate; // => 100 * 0.15 = 15.0
        return Math.min(tax, cap); // => min(15.0, 10.0) = 10.0 — capped
    }
}
 
class DateHelper {
    // => All methods relate to date operations
    public String getDayOfWeek(LocalDate date) {
        return date.getDayOfWeek().name(); // => "MONDAY" or "TUESDAY" etc.
    }
 
    public boolean isWeekend(LocalDate date) {
        return date.getDayOfWeek().getValue() >= 6;
        // => true on Saturday (6) or Sunday (7)
    }
 
    public static void main(String[] args) {
        StringFormatter fmt = new StringFormatter();
        System.out.println(fmt.formatTitle("hello world")); // => HELLO WORLD
 
        TaxCalculator tax = new TaxCalculator();
        System.out.println(tax.calculate(200, 0.1)); // => 20.0
    }
}

// => POOR ENCAPSULATION: mutable public fields invite inconsistent state
public class PoorTemperature {
    public double celsius;              // => public: anyone can set this to -999
    public double fahrenheit;           // => computed at construction only
 
    public PoorTemperature(double celsius) {
        this.celsius = celsius;
        this.fahrenheit = celsius * 9.0 / 5 + 32;
        // => Problem: if caller sets celsius later, fahrenheit stays stale
    }
 
    public static void main(String[] args) {
        PoorTemperature poor = new PoorTemperature(100);
        System.out.println(poor.celsius);    // => 100.0
        System.out.println(poor.fahrenheit); // => 212.0
        poor.celsius = 50;                   // => direct mutation — fahrenheit is now stale!
        System.out.println(poor.fahrenheit); // => 212.0 (wrong! should be 122.0)
    }
}

// => WELL ENCAPSULATED: private field, derived properties computed on demand
public class Temperature {
    private final double celsius; // => private: external code cannot set directly
 
    public Temperature(double celsius) {
        validate(celsius);        // => validates at construction time
        this.celsius = celsius;   // => stored once, never exposed for direct write
    }
 
    private static void validate(double celsius) {
        if (celsius < -273.15) {
            throw new IllegalArgumentException("Temperature below absolute zero: " + celsius);
            // => physics constraint enforced by the class, not by callers
        }
    }
 
    public double getCelsius() { return celsius; }
    // => read-only access — no setter means no stale risk
 
    public double getFahrenheit() {
        return celsius * 9.0 / 5 + 32;
        // => always computed from celsius — never stale
        // => celsius=100 → fahrenheit=212.0
    }
 
    public double getKelvin() {
        return celsius + 273.15; // => always derived from single source of truth
    }
 
    public Temperature toCelsius(double value) {
        return new Temperature(value); // => returns NEW instance — immutable pattern
    }
 
    public static void main(String[] args) {
        Temperature t = new Temperature(100);
        System.out.println(t.getCelsius());    // => 100.0
        System.out.println(t.getFahrenheit()); // => 212.0
        System.out.println(t.getKelvin());     // => 373.15
        // => t.celsius = 50 ← compile error: field is private — cannot bypass encapsulation
    }
}

// => INHERITANCE: rigid "is-a" hierarchy that breaks when adding Penguin
class Bird {
    public String fly() {
        return "Flying"; // => default fly behavior for all Birds
    }
}
 
class DuckInheritance extends Bird {
    public String quack() {
        return "Quack"; // => duck-specific behavior
    }
}
 
class PenguinInheritance extends Bird {
    @Override
    public String fly() {
        throw new UnsupportedOperationException("Penguins cannot fly");
        // => Penguin is-a Bird, but must break the Bird contract
        // => This is an LSP violation — any code using Bird.fly() breaks for Penguin
    }
}

// => BEHAVIOR INTERFACES — define what behaviors exist
interface FlyBehavior {
    String fly(); // => contract for any flying behavior
}
 
interface SwimBehavior {
    String swim(); // => contract for any swimming behavior
}
 
// => CONCRETE BEHAVIORS — small, focused, reusable
class CanFly implements FlyBehavior {
    public String fly() {
        return "Flapping wings"; // => standard flying behavior
    }
}
 
class CannotFly implements FlyBehavior {
    public String fly() {
        return "Cannot fly"; // => used by non-flying birds — no exception
    }
}
 
class CanSwim implements SwimBehavior {
    public String swim() {
        return "Swimming"; // => used by aquatic birds
    }
}
 
// => COMPOSED BIRDS — each bird assembles the behaviors it actually has
class Eagle {
    private final FlyBehavior fly = new CanFly(); // => eagles can fly
 
    public String fly() { return fly.fly(); }
    // => delegates to behavior object — Output: "Flapping wings"
}
 
class Duck {
    private final FlyBehavior flyBehavior = new CanFly();   // => ducks can fly
    private final SwimBehavior swimBehavior = new CanSwim(); // => and swim
 
    public String fly()  { return flyBehavior.fly(); }   // => Output: "Flapping wings"
    public String swim() { return swimBehavior.swim(); } // => Output: "Swimming"
}
 
class Penguin {
    private final FlyBehavior flyBehavior  = new CannotFly(); // => cannot fly
    private final SwimBehavior swimBehavior = new CanSwim();  // => but can swim
 
    public String fly()  { return flyBehavior.fly(); }   // => Output: "Cannot fly"
    public String swim() { return swimBehavior.swim(); } // => Output: "Swimming"
}
 
class BirdCompositionDemo {
    public static void main(String[] args) {
        Duck duck = new Duck();
        System.out.println(duck.fly());  // => Flapping wings
        System.out.println(duck.swim()); // => Swimming
 
        Penguin penguin = new Penguin();
        System.out.println(penguin.fly()); // => Cannot fly (no exception thrown)
    }
}

// => INTERFACE WITH DEFAULT METHODS: adds serialization capability to any implementing class
import java.util.Map;
import com.google.gson.Gson; // => conceptual — swap with any JSON library
 
interface JsonSerializable {
    // => default method: any class implementing this interface gets toJson() for free
    default String toJson() {
        // => in real code, use Jackson or Gson; shown here as a simple map serialization
        return this.toString(); // => placeholder — real impl would use reflection
        // => Output for Product: '{"name":"Laptop","price":1200.0}'
    }
}
 
interface Timestamped {
    long getCreatedAt(); // => contract: implementing class provides creation time
}
 
// => Product implements BOTH interfaces, gains both capabilities
class Product implements JsonSerializable, Timestamped {
    private final String name;
    private final double price;
    private final long createdAt = System.currentTimeMillis();
    // => creation time recorded at construction
 
    public Product(String name, double price) {
        this.name = name;
        this.price = price; // => stored privately
    }
 
    @Override public long getCreatedAt() { return createdAt; }
    // => satisfies Timestamped contract
 
    @Override public String toString() {
        return "{\"name\":\"" + name + "\",\"price\":" + price + ",\"createdAt\":" + createdAt + "}";
        // => simple serialization — toJson() from interface calls this
    }
 
    public static void main(String[] args) {
        Product product = new Product("Laptop", 1200.0);
        System.out.println(product.toJson());
        // => {"name":"Laptop","price":1200.0,"createdAt":...}
        // => toJson comes from the interface — Product class has zero duplication
    }
}

// => EXPLICIT COMPOSITION: behaviors are injected, not inherited
interface Serializer {
    String serialize(java.util.Map<String, Object> data); // => contract for serialization
}
 
interface Clock {
    long now(); // => contract for time retrieval
}
 
// => CONCRETE IMPLEMENTATIONS — swappable in tests
class SimpleSerializer implements Serializer {
    public String serialize(java.util.Map<String, Object> data) {
        return data.toString(); // => simplified; real impl uses Jackson/Gson
        // => Output: {id=1, amount=99.9, createdAt=...}
    }
}
 
class SystemClock implements Clock {
    public long now() { return System.currentTimeMillis(); }
    // => returns current Unix timestamp in milliseconds
}
 
class Order {
    private final int id;
    private final double amount;
    private final Serializer serializer; // => injected behavior
    private final long createdAt;        // => recorded via injected clock
 
    public Order(int id, double amount, Serializer serializer, Clock clock) {
        this.id = id;
        this.amount = amount;
        this.serializer = serializer; // => stored — can be swapped in tests
        this.createdAt = clock.now(); // => delegates time to clock — testable
    }
 
    public String toJson() {
        return serializer.serialize(java.util.Map.of(
            "id", id, "amount", amount, "createdAt", createdAt
        ));
        // => Output: {id=1, amount=99.9, createdAt=...}
    }
 
    public static void main(String[] args) {
        Order order = new Order(1, 99.9, new SimpleSerializer(), new SystemClock());
        System.out.println(order.toJson());
        // => {id=1, amount=99.9, createdAt=...}
        // => In tests: inject FakeClock that returns a fixed timestamp — fully deterministic
    }
}

// => REPOSITORY INTERFACE — defines the contract; no storage details
import java.util.*;
 
record Product(int id, String name, double price) {}
 
interface ProductRepository {
    Optional<Product> findById(int productId); // => find or empty — no null
    void save(Product product);                // => upsert by id
    List<Product> findAll();                   // => returns all stored products
}
 
// => IN-MEMORY IMPLEMENTATION — for tests and fast prototyping
class InMemoryProductRepository implements ProductRepository {
    private final Map<Integer, Product> store = new HashMap<>();
    // => in-memory map as backing store
 
    @Override
    public Optional<Product> findById(int productId) {
        return Optional.ofNullable(store.get(productId));
        // => returns Optional.of(product) or Optional.empty()
    }
 
    @Override
    public void save(Product product) {
        store.put(product.id(), product); // => upsert by id key
    }
 
    @Override
    public List<Product> findAll() {
        return List.copyOf(store.values()); // => defensive copy — no mutation
    }
}
 
// => SERVICE — uses only the repository interface, not any concrete implementation
class ProductService {
    private final ProductRepository repo;
    // => injected repository — service never knows the backing store type
 
    public ProductService(ProductRepository repo) { this.repo = repo; }
 
    public Product addProduct(int id, String name, double price) {
        Product product = new Product(id, name, price);
        repo.save(product);              // => delegates persistence to repository
        return product;                  // => returns the saved product
    }
 
    public Optional<Product> getProduct(int id) {
        return repo.findById(id);
        // => delegates retrieval — business layer never imports a DB driver
    }
 
    public static void main(String[] args) {
        ProductRepository repo = new InMemoryProductRepository(); // => inject in-memory impl
        ProductService service = new ProductService(repo);
 
        Product p = service.addProduct(1, "Laptop", 1200.0);
        System.out.println(p);                     // => Product[id=1, name=Laptop, price=1200.0]
        System.out.println(service.getProduct(1)); // => Optional[Product[id=1, name=Laptop, price=1200.0]]
        System.out.println(service.getProduct(99)); // => Optional.empty
    }
}

import java.util.*;
import java.util.stream.Collectors;
 
// => DOMAIN-SPECIFIC REPOSITORY — queries named for business intent
interface OrderRepository {
    // => save: upsert an order by its id
    void save(Map<String, Object> order);
    // => findById: returns order map or null if not found
    Map<String, Object> findById(int id);
    // => findByCustomerId: named for business question "which orders belong to this customer?"
    List<Map<String, Object>> findByCustomerId(int customerId);
    // => findPendingAbove: named for business question "which pending orders exceed this threshold?"
    List<Map<String, Object>> findPendingAbove(double threshold);
}
 
// => IN-MEMORY IMPLEMENTATION — satisfies all query methods without a real database
class InMemoryOrderRepository implements OrderRepository {
    // => backing store: order id -> order map
    private final Map<Integer, Map<String, Object>> orders = new HashMap<>();
 
    @Override
    public void save(Map<String, Object> order) {
        orders.put((int) order.get("id"), order); // => upsert: overwrites if id already exists
    }
 
    @Override
    public Map<String, Object> findById(int id) {
        return orders.get(id); // => returns order or null
    }
 
    @Override
    public List<Map<String, Object>> findByCustomerId(int customerId) {
        // => stream all orders, keep only those matching the given customerId
        return orders.values().stream()
            .filter(o -> (int) o.get("customerId") == customerId)
            .collect(Collectors.toList());
        // => result contains only orders for customerId
    }
 
    @Override
    public List<Map<String, Object>> findPendingAbove(double threshold) {
        // => keep orders that are pending AND exceed the threshold amount
        return orders.values().stream()
            .filter(o -> "pending".equals(o.get("status")) && (double) o.get("total") > threshold)
            .collect(Collectors.toList());
        // => result contains only qualifying pending orders
    }
}
 
// => USAGE: business code uses named queries — reads like a business document
public class Example22 {
    public static void main(String[] args) {
        InMemoryOrderRepository repo = new InMemoryOrderRepository();
        // => add three test orders to the in-memory store
        repo.save(Map.of("id", 1, "customerId", 10, "total", 150.0, "status", "pending"));
        repo.save(Map.of("id", 2, "customerId", 10, "total", 800.0, "status", "pending"));
        repo.save(Map.of("id", 3, "customerId", 20, "total", 200.0, "status", "shipped"));
 
        System.out.println(repo.findByCustomerId(10).size()); // => 2 (orders 1 and 2 belong to customer 10)
        System.out.println(repo.findPendingAbove(500).size()); // => 1 (only order 2: total 800 > 500)
    }
}

import java.util.Map;
 
// ============================================================
// DOMAIN OBJECTS — each owns its own rules and state
// ============================================================
class Customer {
    private final int id;
    private double credit;
    // => credit tracks available spending power for this customer
 
    Customer(int id, double credit) {
        this.id = id;
        this.credit = credit; // => initial credit balance
    }
 
    boolean canAfford(double amount) {
        return credit >= amount; // => true if credit covers amount
    }
 
    void deduct(double amount) {
        credit -= amount; // => reduces available credit by amount
    }
 
    int getId() { return id; }
}
 
class Product {
    private final int id;
    final String name;
    final double price;
    private int stock;
    // => stock tracks how many units remain
 
    Product(int id, String name, double price, int stock) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.stock = stock; // => initial inventory count
    }
 
    boolean isAvailable() {
        return stock > 0; // => true when at least one unit remains
    }
 
    void reserve() {
        stock -= 1; // => decrements stock by one when an order is placed
    }
}
 
// ============================================================
// SERVICE LAYER — orchestrates the "place order" use case
// ============================================================
class OrderService {
    private final Map<Integer, Customer> customers;
    private final Map<Integer, Product> products;
    // => injected collections act as simple in-memory repositories
 
    OrderService(Map<Integer, Customer> customers, Map<Integer, Product> products) {
        this.customers = customers; // => data source for customer lookups
        this.products = products;   // => data source for product lookups
    }
 
    String placeOrder(int customerId, int productId) {
        // => STEP 1: retrieve both domain objects — guard if missing
        Customer customer = customers.get(customerId);
        Product product = products.get(productId);
        if (customer == null || product == null) return "Customer or product not found";
        // => exit early if either entity is missing
 
        // => STEP 2: apply business rules via domain object methods
        if (!product.isAvailable()) return "'" + product.name + "' is out of stock";
        // => domain object owns the availability rule
 
        if (!customer.canAfford(product.price))
            return String.format("Insufficient credit for '%s' ($%.2f)", product.name, product.price);
        // => domain object owns the affordability rule
 
        // => STEP 3: execute state changes — service coordinates, domain mutates
        product.reserve();                   // => domain: decrements stock
        customer.deduct(product.price);      // => domain: deducts credit
        return "Order placed: " + product.name + " for customer " + customerId;
        // => Output: "Order placed: Laptop for customer 1"
    }
}
 
public class Example23 {
    public static void main(String[] args) {
        var customers = Map.of(
            1, new Customer(1, 2000.0),  // => customer 1 has $2000 credit
            2, new Customer(2, 100.0)    // => customer 2 has $100 credit
        );
        var products = Map.of(
            10, new Product(10, "Laptop", 1200.0, 2),       // => 2 in stock
            11, new Product(11, "Headphones", 150.0, 0)     // => out of stock
        );
        var service = new OrderService(customers, products);
 
        System.out.println(service.placeOrder(1, 10)); // => Order placed: Laptop for customer 1
        System.out.println(service.placeOrder(2, 10)); // => Insufficient credit for 'Laptop' ($1200.00)
        System.out.println(service.placeOrder(1, 11)); // => 'Headphones' is out of stock
    }
}

import java.util.HashMap;
import java.util.Map;
 
// => Java uses exceptions for error handling in service layers
// => Custom exception carries domain-meaningful error information
 
// => DOMAIN EXCEPTION — carries a business error, not a system failure
class ReservationException extends RuntimeException {
    ReservationException(String message) {
        super(message); // => wraps the failure reason in an exception
    }
}
 
// => INVENTORY: simple in-memory stock store
class InventoryService {
    // => inventory maps item name to available quantity
    private final Map<String, Integer> inventory = new HashMap<>(Map.of("Widget", 10, "Gadget", 0));
 
    // => reserve: throws ReservationException on any business rule failure
    public Map<String, Object> reserve(String item, int quantity) {
        Integer stock = inventory.get(item);
 
        if (stock == null) {
            throw new ReservationException("Item '" + item + "' does not exist");
            // => explicit failure: item not in catalog
        }
        if (stock < quantity) {
            throw new ReservationException(
                "Insufficient stock for '" + item + "': have " + stock + ", requested " + quantity
            );
            // => explicit failure: not enough stock
        }
 
        inventory.put(item, stock - quantity); // => decrements stock by requested quantity
        return Map.of("item", item, "reserved", quantity);
        // => returns success payload with reservation details
    }
}
 
// => CONTROLLER: catches domain exception — error path is always explicit
class Example24 {
    static String handleReserve(InventoryService service, String item, int quantity) {
        try {
            var result = service.reserve(item, quantity);
            // => success: result contains item and reserved count
            return "Reserved " + result.get("reserved") + "x " + result.get("item");
            // => Output: "Reserved 3x Widget"
        } catch (ReservationException e) {
            return "Reservation failed: " + e.getMessage();
            // => Output: "Reservation failed: Insufficient stock for 'Gadget': have 0, requested 1"
        }
    }
 
    public static void main(String[] args) {
        var service = new InventoryService();
        System.out.println(handleReserve(service, "Widget", 3));  // => Reserved 3x Widget
        System.out.println(handleReserve(service, "Gadget", 1));  // => Reservation failed: Insufficient stock...
        System.out.println(handleReserve(service, "Unknown", 1)); // => Reservation failed: Item 'Unknown' does not exist
    }
}