SOLID Principles: Violations and Fixes

// VIOLATION: Invoice has four unrelated reasons to change
class Invoice {
    List<LineItem> items;
 
    double calculateTotal() { /* pricing logic */ return 0; }
 
    void printToPdf() { /* PDF rendering logic — changes if layout changes */ }
 
    void saveToDatabase() { /* SQL — changes if schema/DB changes */ }
 
    void emailToCustomer() { /* SMTP — changes if email provider changes */ }
}

// FIXED: each class owns exactly one axis of change
class Invoice {
    List<LineItem> items;
    double calculateTotal() { /* pricing logic only */ return 0; }
}
 
class InvoicePdfRenderer {
    byte[] render(Invoice invoice) { /* ... */ return new byte[0]; }
}
 
class InvoiceRepository {
    void save(Invoice invoice) { /* ... */ }
}
 
class InvoiceMailer {
    void send(Invoice invoice, String recipient) { /* ... */ }
}

// VIOLATION: every new discount type means editing this method
class DiscountCalculator {
    double apply(String customerType, double amount) {
        if (customerType.equals("REGULAR")) return amount;
        if (customerType.equals("PREMIUM")) return amount * 0.9;
        if (customerType.equals("VIP")) return amount * 0.8;
        // adding "STUDENT" means modifying this tested method again
        throw new IllegalArgumentException("Unknown type");
    }
}

// FIXED: Strategy pattern — new discount = new class, zero edits to existing code
interface DiscountStrategy {
    double apply(double amount);
}
 
class RegularDiscount implements DiscountStrategy {
    public double apply(double amount) { return amount; }
}
 
class PremiumDiscount implements DiscountStrategy {
    public double apply(double amount) { return amount * 0.9; }
}
 
class VipDiscount implements DiscountStrategy {
    public double apply(double amount) { return amount * 0.8; }
}
 
// Adding StudentDiscount later touches ZERO existing, tested classes.
class DiscountCalculator {
    double apply(DiscountStrategy strategy, double amount) {
        return strategy.apply(amount);
    }
}

// VIOLATION: classic Square-extends-Rectangle
class Rectangle {
    protected int width, height;
    void setWidth(int w) { this.width = w; }
    void setHeight(int h) { this.height = h; }
    int area() { return width * height; }
}
 
class Square extends Rectangle {
    @Override void setWidth(int w) { width = w; height = w; }  // silently changes height too!
    @Override void setHeight(int h) { width = h; height = h; }
}
 
// Client code that works for any Rectangle breaks for Square:
void resize(Rectangle r) {
    r.setWidth(5);
    r.setHeight(10);
    assert r.area() == 50; // PASSES for Rectangle, FAILS for Square (area=100)
}

// FIXED: don't force an is-a relationship that isn't behaviorally true.
// Square and Rectangle are both Shapes, but Square is not a "substitutable Rectangle".
interface Shape { int area(); }
 
final class Rectangle implements Shape {
    private final int width, height;
    Rectangle(int width, int height) { this.width = width; this.height = height; }
    public int area() { return width * height; }
}
 
final class Square implements Shape {
    private final int side;
    Square(int side) { this.side = side; }
    public int area() { return side * side; }
}

// VIOLATION: subclass narrows the contract by throwing on valid superclass input
class ReadWriteRepository<T> {
    void save(T item) { /* ... */ }
}
 
class ReadOnlyRepository<T> extends ReadWriteRepository<T> {
    @Override
    void save(T item) {
        throw new UnsupportedOperationException("read-only"); // breaks LSP
    }
}
// Any code that accepts a ReadWriteRepository and calls save() now
// crashes at runtime for a ReadOnlyRepository — a violation invisible at compile time.

// VIOLATION: fat interface forces irrelevant implementations
interface Worker {
    void code();
    void designUI();
    void writeDocs();
    void deployInfra();
}
 
class BackendEngineer implements Worker {
    public void code() { /* ... */ }
    public void designUI() { throw new UnsupportedOperationException(); } // forced stub
    public void writeDocs() { /* ... */ }
    public void deployInfra() { throw new UnsupportedOperationException(); } // forced stub
}

// FIXED: segregated, role-specific interfaces — implement only what applies
interface Coder { void code(); }
interface Designer { void designUI(); }
interface TechnicalWriter { void writeDocs(); }
interface InfraEngineer { void deployInfra(); }
 
class BackendEngineer implements Coder, TechnicalWriter {
    public void code() { /* ... */ }
    public void writeDocs() { /* ... */ }
    // no forced stubs — this class simply doesn't implement Designer or InfraEngineer
}

// VIOLATION: OrderService instantiates its own dependency — tightly coupled
class OrderService {
    private final MySqlOrderRepository repository = new MySqlOrderRepository(); // concrete!
 
    void placeOrder(Order order) {
        repository.save(order);
    }
}
// Testing OrderService requires a real MySQL connection. Swapping databases
// means editing OrderService itself.

// FIXED: depend on an interface, inject the implementation
interface OrderRepository {
    void save(Order order);
}
 
class MySqlOrderRepository implements OrderRepository {
    public void save(Order order) { /* JDBC/JPA code */ }
}
 
class OrderService {
    private final OrderRepository repository; // abstraction, injected
 
    OrderService(OrderRepository repository) { // constructor injection
        this.repository = repository;
    }
 
    void placeOrder(Order order) {
        repository.save(order);
    }
}
 
// Production: OrderService prodService = new OrderService(new MySqlOrderRepository());
// Test:       OrderService testService = new OrderService(new InMemoryOrderRepository());