Principio de Segregación de Interfaces en SOLID: no hagas que una clase sepa más de lo que necesita

Si alguna vez has trabajado con interfaces gigantescas que parecen un menú de restaurante con demasiadas opciones, sabes lo incómodo que puede ser implementarlas. Ahí es donde entra en juego el Principio de Segregación de Interfaces, la «S» olvidada en SOLID que muchos ignoran… hasta que sufren su ausencia.

¿Qué es el Principio de Segregación de Interfaces?

Este principio dice que una clase no debería verse forzada a depender de métodos que no usa. En otras palabras, es mejor tener varias interfaces pequeñas y específicas en lugar de una única y enorme que obligue a las clases a implementar métodos irrelevantes para ellas.

Para explicarlo con una analogía: imagina que contratas a un diseñador gráfico y, además de pedirle ilustraciones, le exiges que haga desarrollo backend. Claramente, no tiene sentido. En programación, hacer esto con interfaces es igual de problemático.

El problema de las interfaces infladas

Supongamos que tenemos la siguiente interfaz en Java:

public interface Trabajador {
    void trabajar();
    void reportarHoras();
    void comer();
}

Aquí estamos asumiendo que todos los trabajadores deben reportar horas y comer. Pero, ¿qué pasa si tenemos freelancers que no llevan un control de horas? ¿O robots que no comen? Estamos obligando a implementar métodos innecesarios.

Aplicando la Segregación de Interfaces

Para solucionar esto, dividimos la interfaz en varias más específicas:

public interface Trabajador {
    void trabajar();
}

public interface Reportable {
    void reportarHoras();
}

public interface Comedor {
    void comer();
}

Ahora podemos crear clases más flexibles y solo implementar lo que realmente necesiten:

public class Empleado implements Trabajador, Reportable, Comedor {
    public void trabajar() { System.out.println("Trabajando..."); }
    public void reportarHoras() { System.out.println("Reportando horas..."); }
    public void comer() { System.out.println("Comiendo..."); }
}

public class Freelancer implements Trabajador {
    public void trabajar() { System.out.println("Trabajando como freelancer..."); }
}

public class Robot implements Trabajador {
    public void trabajar() { System.out.println("Ejecutando tareas..."); }
}

Con esta separación, cada clase solo implementa lo que realmente necesita. 🎯

Beneficios de aplicar este principio

• Menos código innecesario: Las clases solo implementan los métodos que realmente necesitan.
• Mayor flexibilidad: Es más fácil hacer cambios y extender funcionalidades sin afectar otras partes del código.
• Mejor mantenimiento: Menos dependencia entre clases y menos problemas cuando agregamos nuevas funciones.

Conclusión (o casi)

El principio de Segregación de Interfaces es simple: no hagas que una clase implemente métodos que no usa. Al dividir las interfaces en partes más pequeñas y específicas, evitamos código innecesario y mantenemos nuestro software limpio y fácil de mantener.

La próxima vez que diseñes una interfaz, pregúntate: ¿realmente todas las clases que la implementan necesitan cada uno de estos métodos? Si la respuesta es «no», ya sabes lo que tienes que hacer. 😉