Fundamentos de los Principios SOLID

SOLID es un acrónimo que agrupa cinco principios de diseño orientado a objetos, cuyo objetivo es crear código mantenible, extensible y resiliente a fallos.

En Resumen

SOLID: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.

S — Single Responsibility (SRP)

Una clase debe tener una única razón para cambiar.

// Incorrecto: múltiples responsabilidades
class User {
  saveToDatabase() { /* DB */ }
  sendEmail() { /* E-mail */ }
  validateEmail() { /* Validación */ }
}

// Correcto: separado
class User {}
class UserRepository { save(u: User) {} }
class EmailService { send(u: User, msg: string) {} }

O — Open-Closed (OCP)

Abierto para extensión, cerrado para modificación.

// Incorrecto: necesita cambios al agregar un tipo
class DiscountCalculator {
  calculate(type: string): number {
    if (type === 'premium') return 0.8;
    if (type === 'vip') return 0.7;
    return 1.0;
  }
}

// Correcto: Strategy Pattern
interface DiscountStrategy { getFactor(): number; }
class PremiumDiscount implements DiscountStrategy { getFactor() { return 0.8; } }
class VipDiscount implements DiscountStrategy { getFactor() { return 0.7; } }

L — Liskov Substitution (LSP)

Los subtipos deben poder reemplazar a los tipos base sin romper el comportamiento esperado.

// Incorrecto: Penguin no puede volar
class Bird { fly() {} }
class Penguin extends Bird { fly() { throw new Error('Cannot fly'); } }

// Correcto: jerarquía adecuada
interface Bird { layEgg(): void; }
interface FlyingBird extends Bird { fly(): void; }

I — Interface Segregation (ISP)

Ningún cliente debe depender de métodos que no utiliza.

// Incorrecto: interfaz demasiado amplia
interface Worker { work(): void; eat(): void; sleep(): void; }

// Correcto: separado
interface Workable { work(): void; }
interface Eatable { eat(): void; }

D — Dependency Inversion (DIP)

Depende de abstracciones, no de implementaciones concretas.

// Incorrecto: acoplamiento directo
class OrderService {
  private repo = new MySQLDatabase();
}

// Correcto: inyección de dependencias
interface OrderRepository { save(order: Order): void; }
class OrderService {
  constructor(private repo: OrderRepository) {}
}

SOLID en Perspectiva

Principio	Significado	Objetivo
SRP	Single Responsibility	Una clase, una responsabilidad
OCP	Open-Closed	Extensible sin modificación
LSP	Liskov Substitution	Los subtipos reemplazan tipos base
ISP	Interface Segregation	Interfaces pequeñas y específicas
DIP	Dependency Inversion	Abstracción antes que implementación

Puntos Clave para Recordar

• SOLID es un acrónimo de cinco principios de diseño OOP
• SRP: una razón para cambiar por clase
• OCP: extensión sin modificación, utiliza Strategy Pattern
• LSP: los subtipos deben cumplir los contratos
• ISP: muchas interfaces pequeñas en lugar de una grande
• DIP: inyección de dependencias, la abstracción como dependencia

Preguntas Frecuentes

Continuando en el Camino SOLID

El próximo artículo en el camino SOLID explora Análisis y diseño: UML, GRASP, SOLID y objetivos de calidad, donde se aprende cómo los diagramas UML, patrones GRASP y principios SOLID se integran en la arquitectura de software.

Fuentes

1. https://en.wikipedia.org/wiki/SOLID
2. https://www.oreilly.com/library/view/clean-code/9780134661742/
3. https://refactoring.guru/design-patterns/solid-principles

Libros Recomendados sobre Calidad de Software

Si deseas profundizar en SOLID, Clean Code y calidad de software, te recomendamos los siguientes títulos: