Contenido del curso
Principios SOLID
- 2

Qué es el principio de responsabilidad única
05:58 min - 3

Procesador de pagos en Python con Stripe
11:13 min - 4

Cómo aplicar SRP en un procesador de pagos con Stripe
25:19 min - 5

Principio open-closed en Python
02:39 min - 6

Clases abstractas y principio abierto-cerrado
14:46 min - 7

Principio de Liskov en S.O.L.I.D.
03:18 min - 8

Principio de sustitución de Liskov en Python
06:38 min - 9

Principio de segregación de interfaces en SOLID
Viendo ahora - 10

Segregación de interfaces en procesadores de pagos
09:05 min - 11

Principio de inversión de dependencias en SOLID
04:13 min - 12

Principio de inversión de dependencias: servicio de pagos flexible
05:56 min
Reestructuración del proyecto
Patrones de Diseño
- 14

Qué son los patrones de diseño: definición y categorías
03:54 min - 15

Strategy Pattern con Python y setprocessor
01:55 min - 16

Strategy Pattern para pagos en Python
10:58 min - 17

Factory Pattern: centralizar creación de objetos
03:04 min - 18

Patrón Factory para procesar pagos con match
11:06 min - 19

Qué es el patrón Decorator
03:06 min - 20

Patrón decorador en servicios de pagos
12:57 min - 21

Builder Pattern: construcción paso a paso
01:28 min - 22

Builder Pattern aplicado a un servicio de pagos
18:54 min - 23

Observer Pattern en sistemas de eventos
01:48 min - 24

Observer en sistemas de pagos con Python
11:11 min - 25

Chain of Responsibility para validar pagos
02:04 min - 26

Chain of Responsibility en servicios de pagos
16:27 min - 27

Código funcional vs código mantenible en Python
03:19 min
Principio de segregación de interfaces en SOLID
Resumen
El principio de segregación de interfaces (ISP) es la "I" de SOLID y establece que ningún cliente debería verse obligado a depender de interfaces que no utiliza. Aplicarlo te ayuda a escribir código más limpio, modular y fácil de mantener, especialmente si trabajas con clases que comparten contratos amplios.
¿Qué dice el principio de segregación de interfaces?
La definición formal es directa: una clase no debería implementar métodos que no necesita. En lugar de tener una interfaz gigante con múltiples responsabilidades, conviene dividirla en interfaces más pequeñas y específicas según el comportamiento que representan.
¿Qué es el principio de segregación de interfaces? Es la regla de SOLID que evita obligar a una clase a implementar métodos que no usa. Si una interfaz tiene demasiadas responsabilidades, se divide en varias interfaces más pequeñas y específicas.
El ejemplo de la impresora multifuncional
Imagina una interfaz que mezcla operaciones de impresión y escaneo. Una impresora multifuncional puede implementar ambas, perfecto. Pero, ¿qué pasa con una impresora que solo imprime? No tendría sentido obligarla a implementar el método de escaneo. Y al revés: un escáner que solo escanea no debería cargar con métodos de impresión que jamás va a ejecutar.
La solución es separar el contrato en dos: una interfaz para imprimir y otra para escanear. Cada clase implementa solo lo que realmente usa.
¿Por qué importa aplicar ISP en tu código?
Las ventajas son concretas y se notan al mantener proyectos a mediano y largo plazo.
- Mejora la cohesión y reduce el acoplamiento. Esta es la máxima de la construcción de software: que cada componente haga lo suyo y dependa lo menos posible de otros.
- Garantiza la reutilización de componentes. Si el comportamiento de impresión vive en su propia interfaz, puedes usarlo en distintas partes del código sin arrastrar el resto.
- Los cambios no se propagan. Modificar la interfaz de impresión no obliga a tocar la de escaneo ni a las clases que solo escanean.
- Facilita las pruebas unitarias. Al tener contextos separados, puedes probar cada interfaz de forma aislada sin montar dependencias innecesarias.
¿ISP mejora la cohesión o el acoplamiento? Mejora ambos. Aumenta la cohesión porque cada interfaz agrupa solo métodos relacionados, y reduce el acoplamiento porque las clases dependen únicamente de lo que realmente necesitan.
¿Cuándo conviene aplicar el principio de segregación de interfaces?
No todo proyecto necesita aplicar ISP desde el primer día, pero hay señales claras de que ya es momento de segregar.
Señales de que tu interfaz necesita segregarse
- Las interfaces tienen demasiados métodos irrelevantes. Si ves una interfaz con una lista larga de métodos que no se relacionan entre sí, es buen momento de partirla en interfaces más pequeñas.
- Hay clases que no usan todos los métodos de la interfaz. Cuando una clase implementa una interfaz pero deja métodos vacíos o lanza excepciones porque no aplican, ahí tienes un caso claro de ISP.
- Un cambio en la interfaz afecta a muchas clases. Esta es la señal más fuerte. Si modificar algo que debería ser sencillo te obliga a tocar media base de código, la interfaz está cargando demasiadas responsabilidades.
¿Cómo lo aplicarías a un procesador de pagos?
Piensa en un procesador de pagos: probablemente tengas operaciones de cobro, reembolso, validación de tarjetas y notificaciones. Si todas viven en la misma interfaz, una clase que solo necesita cobrar termina obligada a implementar reembolsos y notificaciones que nunca usará. Segregar esos comportamientos en interfaces independientes te permite que cada componente del procesador haga solo lo que le corresponde.
Déjame en los comentarios cómo aplicarías ISP al procesador de pagos que estamos construyendo. ¿Qué interfaces separarías y cuáles dejarías juntas?