SOLID

SRP + OCP + DIP in one small example: payment processing.

// S: each class owns exactly one reason to change.
public class OrderFees {
  public double calculate(Order o) { return o.amount() * 0.02; }
}

// O + D: an interface, implementations plugged from outside.
public interface PaymentGateway {            // DIP: depend on this abstraction
  boolean charge(Order o);
}

public class StripeGateway implements PaymentGateway {
  public boolean charge(Order o) { /* Stripe SDK call */ return true; }
}
public class PaypalGateway implements PaymentGateway {
  public boolean charge(Order o) { /* Paypal SDK call */ return true; }
}

public class Checkout {
  private final PaymentGateway gateway;      // constructor injection (DIP)
  public Checkout(PaymentGateway gateway) { this.gateway = gateway; }

  // Adding "UPI gateway" tomorrow? New class only. Checkout never changes → OCP.
  public void pay(Order o) { gateway.charge(o); }
}

The two letters people struggle to demonstrate: L and I.

// L — VIOLATION: Square "is-a" Rectangle mathematically, not behaviourally.
class Rectangle {
  protected int w, h;
  void setWidth(int w)  { this.w = w; }
  void setHeight(int h) { this.h = h; }
  int area() { return w * h; }
}
class Square extends Rectangle {
  @Override void setWidth(int w)  { this.w = this.h = w; }   // breaks the
  @Override void setHeight(int h) { this.w = this.h = h; }   // parent's contract
}
// Caller written against Rectangle:
//   r.setWidth(5); r.setHeight(4); assert r.area() == 20;  // FAILS for Square
// FIX: no inheritance. Both implement an immutable Shape { int area(); }.

// L — also a violation: a subclass that throws where the base didn't.
class ReadOnlyList<T> extends ArrayList<T> {
  @Override public boolean add(T t) { throw new UnsupportedOperationException(); }
}

// I — VIOLATION: one fat interface forces empty implementations.
interface Worker { void code(); void attendStandup(); void chargeBattery(); }
class Robot implements Worker {
  public void attendStandup() { /* meaningless */ }  // smell
  public void code() {}
  public void chargeBattery() {}
}
// FIX: segregate by client need.
interface Coder { void code(); }
interface Rechargeable { void chargeBattery(); }
class RobotDev implements Coder, Rechargeable {
  public void code() {}
  public void chargeBattery() {}
}