Design Principles

// Violation: validation logic duplicated across service and controller
public class OrderController {
    public void createOrder(OrderRequest req) {
        if (req.getAmount() <= 0) throw new InvalidOrderException();
        if (req.getItems().isEmpty()) throw new InvalidOrderException();
        // ...
    }
}

public class OrderService {
    public void processOrder(Order order) {
        if (order.getAmount() <= 0) throw new InvalidOrderException();
        if (order.getItems().isEmpty()) throw new InvalidOrderException();
        // ...
    }
}

public class OrderValidator {
    public static void validate(Order order) {
        if (order.getAmount() <= 0) throw new InvalidOrderException("Amount must be positive");
        if (order.getItems().isEmpty()) throw new InvalidOrderException("Order must have items");
    }
}

// Over-engineered: generic event bus with plugin architecture for a config reader
public class ConfigReader<T extends Serializable & Comparable<T>>
    extends AbstractConfigLoader<T>
    implements EventDriven<ConfigChangeEvent<T>>, Pluggable<ConfigPlugin<T>> {
    // ...
}

// KISS: just read the config
public class ConfigReader {
    private final Properties props;

    public ConfigReader(String filePath) throws IOException {
        this.props = new Properties();
        try (var in = new FileInputStream(filePath)) {
            props.load(in);
        }
    }

    public String get(String key) {
        return props.getProperty(key);
    }
}

// Fragile: HashSet counts adds in addAll by calling add() internally
public class CountingHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c); // Bug! super.addAll calls add(), double-counting
    }
}

// Fixed with composition: delegate instead of inherit
public class CountingSet<E> implements Set<E> {
    private final Set<E> delegate;
    private int addCount = 0;

    public CountingSet(Set<E> delegate) {
        this.delegate = delegate;
    }

    @Override
    public boolean add(E e) {
        addCount++;
        return delegate.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return delegate.addAll(c); // No double-counting; we don't override delegate internals
    }

    public int getAddCount() {
        return addCount;
    }

    // Remaining Set methods delegate directly...
}

// Violation: reaching through multiple objects ("train wreck")
String city = order.getCustomer().getAddress().getCity();

// Better: ask the object that owns the data
String city = order.getShippingCity();

// Ask (bad): pulling state out and making decisions externally
if (account.getBalance() >= amount && !account.isFrozen()) {
    account.setBalance(account.getBalance() - amount);
    ledger.record(account, amount);
}

// Tell (good): let the object own its behavior
account.withdraw(amount, ledger);  // Account decides if it can, records internally

// Surprising: sort() returns void, modifying in place
list.sort(comparator);  // Java's choice -- familiar, but mutates

// Less surprising for a functional API: return a new sorted list
List<T> sorted = list.stream().sorted(comparator).collect(toList());

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }

    // Getters only, no setters
    public BigDecimal getAmount() { return amount; }
    public Currency getCurrency() { return currency; }
}

public record Money(BigDecimal amount, Currency currency) {
    public Money add(Money other) {
        if (!this.currency.equals(other.currency))
            throw new IllegalArgumentException("Currency mismatch");
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

// Coupled to implementation
ArrayList<String> names = new ArrayList<>();

// Programmed to interface: can swap to LinkedList, unmodifiable list, etc.
List<String> names = new ArrayList<>();

public class NotificationService {
    private final MessageSender sender; // Interface

    public NotificationService(MessageSender sender) {
        this.sender = sender;
    }

    public void notifyUser(User user, String message) {
        sender.send(user.getEmail(), message);
    }
}

// Swap implementations without touching NotificationService
MessageSender email = new EmailSender();
MessageSender sms = new SmsSender();
MessageSender slack = new SlackSender();