Codigo limpio y refactorización

El Principio de Segregación de Interfaces (ISP) establece que las interfaces no deben obligar a las clases que las implementan a depender de métodos que no utilizan. En otras palabras, es mejor tener múltiples interfaces pequeñas y específicas en lugar de una única interfaz grande y general.

  • ¿Por qué es importante?
    Evita que las clases implementen métodos irrelevantes o vacíos, lo que reduce la complejidad, mejora la claridad y facilita el mantenimiento.

Ejemplo 1: Una Interfaz con Métodos No Relevantes

Código Malo (Violación del ISP)

Problema: La clase Coche está obligada a implementar el método volar, que no tiene sentido para un coche. Esto viola el ISP al hacer que Coche dependa de un método que no necesita.

1public interface Vehiculo {
2    void acelerar();
3    void volar();
4}
5
6public class Coche implements Vehiculo {
7    @Override
8    public void acelerar() {
9        System.out.println("El coche está acelerando");
10    }
11
12    @Override
13    public void volar() {
14        throw new UnsupportedOperationException("Un coche no puede volar");
15    }
16}

Código Bueno (Aplicando el ISP)

Solución: Dividimos la interfaz Vehiculo en dos: Vehiculo (que incluye acelerar) y VehiculoVolador (que incluye volar). Ahora las clases solo implementan los métodos relevantes.

1public interface Vehiculo {
2    void acelerar();
3}
4
5public interface VehiculoVolador {
6    void volar();
7}
8
9public class Coche implements Vehiculo {
10    @Override
11    public void acelerar() {
12        System.out.println("El coche está acelerando");
13    }
14}
15
16public class Avion implements Vehiculo, VehiculoVolador {
17    @Override
18    public void acelerar() {
19        System.out.println("El avión está acelerando");
20    }
21
22    @Override
23    public void volar() {
24        System.out.println("El avión está volando");
25    }
26}

Ejemplo 2: Una Interfaz Genérica para Dispositivos

Código Malo (Violación del ISP)

Problema: La interfaz obliga a implementar métodos que no son necesarios, lo que genera código irrelevante y confuso.

1public interface Dispositivo {
2    void imprimir();
3    void escanear();
4}
5
6public class Impresora implements Dispositivo {
7    @Override
8    public void imprimir() {
9        System.out.println("Imprimiendo...");
10    }
11
12    @Override
13    public void escanear() {
14        throw new UnsupportedOperationException("Una impresora no puede escanear");
15    }
16}

Código Bueno (Aplicando el ISP)

Solución: Se dividen las responsabilidades en dos interfaces independientes (Impresora y Escaner). Esto permite que cada clase implemente solo los métodos que necesita.

1public interface Impresora {
2    void imprimir();
3}
4
5public interface Escaner {
6    void escanear();
7}
8
9public class ImpresoraBasica implements Impresora {
10    @Override
11    public void imprimir() {
12        System.out.println("Imprimiendo...");
13    }
14}
15
16public class ImpresoraMultifuncional implements Impresora, Escaner {
17    @Override
18    public void imprimir() {
19        System.out.println("Imprimiendo...");
20    }
21
22    @Override
23    public void escanear() {
24        System.out.println("Escaneando...");
25    }
26}

Beneficios de Aplicar el ISP

  1. Menor complejidad: Las clases no están obligadas a implementar métodos irrelevantes.
  2. Mayor claridad: Las interfaces específicas son más fáciles de entender y usar.
  3. Facilidad de mantenimiento: Es más sencillo agregar nuevas funcionalidades sin modificar clases existentes.

Siguiendo el Principio de Segregación de Interfaces, tu código será más modular, limpio y enfocado en las necesidades reales de cada clase. 😊

  • Loading...
← Principio de Sustitución de Liskov (LSP)Volver al cursoPrincipio de Inversión de Dependencias (DIP) →