SOLID Principles

// ❌ VIOLATION — One class, five reasons to change
public class OrderProcessor {

    // Reason 1: business rules change
    public double calculateTotal(Order order) {
        double sub = order.getItems().stream()
                         .mapToDouble(i -> i.getPrice() * i.getQty()).sum();
        return sub + (sub * 0.18); // GST hardcoded here
    }

    // Reason 2: DB schema or ORM changes
    public void saveOrder(Order order) {
        String sql = "INSERT INTO orders (id, total) VALUES (?, ?)";
        jdbcTemplate.update(sql, order.getId(), calculateTotal(order));
    }

    // Reason 3: email provider or template changes
    public void sendConfirmation(Order order) {
        SimpleMailMessage msg = new SimpleMailMessage();
        msg.setTo(order.getCustomerEmail());
        msg.setSubject("Order Confirmed #" + order.getId());
        msg.setText("Your order total is ₹" + calculateTotal(order));
        mailSender.send(msg);
    }

    // Reason 4: log format or destination changes
    public void logOrder(Order order) {
        String line = LocalDateTime.now() + " | ORDER | " + order.getId();
        Files.write(Paths.get("orders.log"), line.getBytes(), APPEND);
    }

    // Reason 5: report format changes
    public String generateDailyReport(List<Order> orders) {
        return orders.stream()
                     .map(o -> o.getId() + ": ₹" + calculateTotal(o))
                     .collect(Collectors.joining("\n"));
    }
}

// ❌ VIOLATION — Adding a new payment type means editing this class

public class PaymentProcessor {

    public void processPayment(Payment payment) {
        if (payment.getType().equals("CREDIT_CARD")) {
            // credit card logic
            System.out.println("Charging card ending in " + payment.getLast4());
        } else if (payment.getType().equals("UPI")) {
            // UPI logic
            System.out.println("Sending UPI request to " + payment.getUpiId());
        } else if (payment.getType().equals("NET_BANKING")) {
            // net banking logic
            System.out.println("Redirecting to bank: " + payment.getBankCode());
        }
        // ← next engineer adds "CRYPTO" here, touching existing code
        // Every new payment type = modification = risk of breaking existing types
    }
}

// ❌ VIOLATION — Square breaks the contract of Rectangle

public class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int w)  { this.width  = w; }
    public void setHeight(int h) { this.height = h; }
    public int  getArea()        { return width * height; }
}

// Square IS-A Rectangle... geometrically. But behaviourally?
public class Square extends Rectangle {
    @Override
    public void setWidth(int w) {
        this.width  = w;
        this.height = w;  // ← forces equal sides
    }
    @Override
    public void setHeight(int h) {
        this.width  = h;  // ← forces equal sides
        this.height = h;
    }
}

// Client code written against Rectangle contract
public void resizeAndCheck(Rectangle r) {
    r.setWidth(5);
    r.setHeight(10);
    // Developer expects: 5 × 10 = 50
    assert r.getArea() == 50; // ✓ passes for Rectangle
                               // ✗ FAILS for Square — area is 100!
}
// Square cannot be substituted for Rectangle without breaking behaviour.
// This violates the Liskov Substitution Principle.

// ❌ VIOLATION — Fat interface forces irrelevant method implementations

public interface Worker {
    void work();
    void eat();       // ← robots don't eat
    void sleep();     // ← robots don't sleep
    void attendMeeting(); // ← contractors might not
    void submitTimesheet();
}

// Robot is forced to implement biologically absurd methods
public class Robot implements Worker {
    public void work()            { System.out.println("Welding..."); }
    public void eat()             { throw new UnsupportedOperationException("Robots don't eat!"); }
    public void sleep()           { throw new UnsupportedOperationException("Robots don't sleep!"); }
    public void attendMeeting()   { System.out.println("Attending meeting..."); }
    public void submitTimesheet() { throw new UnsupportedOperationException("No timesheet for robots!"); }
}

// Freelancer forced to implement internal HR methods
public class Freelancer implements Worker {
    public void work()            { System.out.println("Working remotely..."); }
    public void eat()             { System.out.println("Eating lunch..."); }
    public void sleep()           { System.out.println("Sleeping..."); }
    public void attendMeeting()   { throw new UnsupportedOperationException("Not invited!"); }
    public void submitTimesheet() { throw new UnsupportedOperationException("Not an employee!"); }
}