Principio de Segregación de Interfaces (ISP) – SOLID explicado con ejemplos

El Principio de Segregación de Interfaces es otro de los principios SOLID y establece que:

Una clase no debería verse obligada a depender de métodos que no utiliza. 

En otras palabras, en lugar de crear una interfaz grande con muchos métodos, es mejor dividirla (segregar) en interfaces más pequeñas y específicas.

Pero.. ¿Por qué?

Obliga a implementar métodos innecesarios

Si una clase solo necesita una "parte" de la funcionalidad de una interfaz, pero esta interfaz es muy grande, se va a ver obligada a implementar métodos que no usa. Esto es casi que inevitable si no buscamos la manera de separar mejor las responsabilidades.

Imaginemos una interfaz IVehiculo que tiene los siguientes métodos:

public interface IVehiculo {

    void Conducir();

    void Volar();

    void Navegar();

}

Si una clase Auto implementa esta interfaz, se ve obligado a definir métodos como Volar() o Navegar(), aunque un auto no vuela ni navega.

public class Auto : IVehiculo {

    public void Conducir() { Console.WriteLine("Conduciendo"); }

    public void Volar() { throw new NotImplementedException(); } 

    public void Navegar() { throw new NotImplementedException(); }

}

El código tiene métodos que no le sirven, lo que genera código innecesario y difícil de mantener.

Dificulta la extensibilidad del código

Si más adelante queremos agregar un barco (Barco), un avión (Avion), etc., todos tendrán que implementar los métodos de IVehiculo, incluso aquellos que no aplican a ellos..

En su lugar, es mejor separar la interfaz en partes más pequeñas:

public interface IConducible { void Conducir(); }

public interface IVolador { void Volar(); }

public interface INavegable { void Navegar(); }

Y ahora las clases pueden implementar solo lo que necesitan:

 public class Auto : IConducible {
public void Conducir() { Console.WriteLine("Conduciendo"); }

}

public class Avion : IVolador {

    public void Volar() { Console.WriteLine("Volando"); }

}

public class Barco : INavegable {

    public void Navegar() { Console.WriteLine("Navegando"); }

}

Código más difícil de mantener y entender

Si una interfaz tiene muchos métodos, cualquier cambio en ella afectará a todas las clases que la implementan, incluso aquellas que no usan ciertos métodos.

Si IVehiculo tenía 20 métodos y querés cambiar uno, todas las clases que implementan IVehiculo tienen que actualizarse, aunque no usen ese método. Esto puede volverse un problema grave en sistemas grandes y difíciles de escalar.

Esto genera acoplamiento innecesario y hace más difícil modificar el código.

Ventajas de este principio

Código más modular y reutilizable

Al dividir una interfaz grande en interfaces más pequeñas y especializadas, evitamos que las clases implementen métodos innecesarios. Esto hace que cada interfaz pueda ser reutilizada en distintos contextos sin forzar dependencias no deseadas.

Por ejemplo, una interfaz IVolador puede ser implementada por un Avión o un Dron, sin afectar a clases que no tienen la capacidad de volar, como un Barco.

Menor acoplamiento y mejora el mantenimiento

Cuando una interfaz tiene demasiadas responsabilidades, cualquier cambio en ella impacta a todas las clases que la implementan, incluso si no usan ciertas funcionalidades.

Con interfaces más pequeñas, reducimos el impacto de los cambios, ya que solo afectan a las clases que realmente necesitan modificar su comportamiento. Esto hace que el código sea más fácil de entender, probar y mantener a lo largo del tiempo.

Implementaciones más flexibles y escalables

Si el programa crece y se agregan nuevas funcionalidades, con una interfaz bien segmentada podemos incorporar nuevas clases sin modificar las existentes. Esto respeta otro principio SOLID: el Principio de Abierto/Cerrado (Open/Closed Principle), que sugiere que el código debe estar abierto a la extensión pero cerrado a la modificación.

Por ejemplo, si queremos agregar un Submarino, simplemente implementamos INavegable, sin tocar el código de Auto, Avión o Barco.

Espero haber sido lo suficientemente claro. Decidí enfocarme primero en los aspectos negativos porque así fue como logré entender este principio en su momento. Me pregunté por qué debería respetarlo y cuáles serían las consecuencias de no hacerlo, para luego profundizar en los aspectos más técnicos.

De cualquier manera, los comentarios y sugerencias siempre son bienvenidos.

Índice SOLID:

1. Single Responsability Principle
2. Open/Closed Principle
3. Liskov Substitution Principle
4. Interface Segregation Principle (estás acá)
5. Dependency Inversion Principle