SOLID Principles Cheat Sheet

// Violates SRP: handles both persistence and formattingclass Report {    void generate() { /* build report data */ }    void saveToFile(String path) { /* file I/O */ }    void printToConsole() { /* formatting + printing */ }}// Follows SRP: each class has one reason to changeclass Report {    void generate() { /* build report data */ }}class ReportSaver {    void saveToFile(Report report, String path) { /* file I/O */ }}class ReportPrinter {    void printToConsole(Report report) { /* formatting */ }}

interface PaymentMethod {    void pay(double amount);}class CreditCardPayment implements PaymentMethod {    public void pay(double amount) { /* charge card */ }}class PayPalPayment implements PaymentMethod {    public void pay(double amount) { /* charge PayPal */ }}// Adding a new payment method requires no changes to Checkoutclass Checkout {    private final PaymentMethod paymentMethod;    Checkout(PaymentMethod paymentMethod) {        this.paymentMethod = paymentMethod;    }    void completeOrder(double total) {        paymentMethod.pay(total);    }}

// Violates LSP: Square changes Rectangle's expected behaviorclass Rectangle {    protected int width, height;    void setWidth(int w) { width = w; }    void setHeight(int h) { height = h; }    int area() { return width * height; }}class Square extends Rectangle {    void setWidth(int w) { width = height = w; }  // breaks Rectangle's contract    void setHeight(int h) { width = height = h; }}// Follows ISP: split a fat interface into focused onesinterface Printer { void print(Document d); }interface Scanner { void scan(Document d); }// SimplePrinter only implements Printer, not forced to implement scan()class SimplePrinter implements Printer {    public void print(Document d) { /* ... */ }}

interface Logger {  log(msg: string): void;}class ConsoleLogger implements Logger {  log(msg: string) { console.log(msg); }}class OrderService {  // depends on the abstraction, injected, not `new ConsoleLogger()` inline  constructor(private logger: Logger) {}  placeOrder(id: string) {    this.logger.log(`order ${id} placed`);  }}// Composition root -- the only place that knows concrete typesconst logger: Logger = new ConsoleLogger();const service = new OrderService(logger);// Swapping to a FileLogger or NullLogger (for tests) touches only// this one wiring point, never OrderService itself.

// Fat interface -- every implementer must support everythinginterface UserRepository {  findById(id: string): User;  save(u: User): void;  delete(id: string): void;  bulkImport(rows: User[]): void;  auditLog(): AuditEntry[];}// Segregated role interfacesinterface UserReader {  findById(id: string): User;}interface UserWriter {  save(u: User): void;  delete(id: string): void;}// A read-only reporting service depends only on UserReader --// a mock in tests implements one method, not five.class ReportingService {  constructor(private users: UserReader) {}}

# Smell: methods cluster into two disjoint groups that never touch# the same fields -- a sign the class has two responsibilities.class InvoicePrinter:    def __init__(self, items, tax_rate):        self.items = items        self.tax_rate = tax_rate        self._connection = None          # only used by save_* methods    def subtotal(self):                  # touches: items        return sum(i.price for i in self.items)    def total(self):                     # touches: items, tax_rate        return self.subtotal() * (1 + self.tax_rate)    def save_to_db(self):                # touches: _connection only        self._connection.execute("INSERT ...")    def save_to_s3(self):                # touches: _connection only        self._connection.upload(...)# subtotal/total form one cluster (pricing logic); save_to_db/save_to_s3# form another (persistence) -- split into InvoiceCalculator and# InvoiceRepository.

class FileValidator {    // precondition: path must be non-null    boolean isValid(String path) {        return path != null && path.endsWith(".txt");    }}// Violates LSP: strengthens the precondition (now also requires// the file to exist on disk), which callers of the base type// don't expect and won't check for.class StrictFileValidator extends FileValidator {    boolean isValid(String path) {        return super.isValid(path) && new File(path).exists();    }}// A caller written against FileValidator that passes a path for a// not-yet-created file works with the base class but throws// unexpected behavior downstream when swapped to StrictFileValidator --// LSP requires subtypes to only weaken preconditions or strengthen// postconditions, never the reverse.