Principios SOLID: (4) Interface Segregation Principle

En nuestros posts anteriores, hemos explorado en profundidad varios de los Principios SOLID, una serie de lineamientos esenciales en el mundo de la programación orientada a objetos que transforman radicalmente la forma en que diseñamos y estructuramos nuestro código.

Hoy vamos a hablar sobre el cuarto de los principios, este es conocido como ‘Interface Segregation Principle‘ o en español ‘Principio de Segregación de Interfaces’.

¿Qué es el Interface Segregation Principle de los principios SOLID?

Este principio nos dice que una clase nunca debe extender de interfaces con métodos que no usa, por el principio de segregación de interfaces busca que las interfaces sean lo más pequeñas y específicas posible de modo que cada clase solo implemente los métodos que necesita.

¿Cómo detectar que estamos violando el principio de segregación de interfaces?

• Estaremos violando este principio si Tenemos clases que implementan métodos de interfaces que no se usan.

• Otro caso de violación del principio sería cuando definimos interfaces con parámetros que no se van a utilizar en todas las clases.

• Otra señal de que nos estamos saltando el principio será cuando tenemos interfaces muy grandes. Probablemente estemos definiendo métodos que no son genéricos y que otras clases que implementen esta interfaz no puedan usar.

¿Cómo solucionar la violación del principio?

Podremos solucionar la violación del principio dividiendo interfaces grandes con métodos que no todas las clases que la implementan usan, por clases mas pequeñas con métodos usados por las clases

En el caso de que tengamos interfaces con parámetros definidos, deberemos valorar si es un elemento común entre las clases que implementan esa interfaz. Y, si no lo es, deberemos eliminarlos.

Ejemplo de implementación ERRONEA del principio de segregación de interfaces

Tenemos la siguiente interfaz definida (animal):

export default interface AnimalInterface {
  run(),
  eat(),
}

y las dos siguientes clases que lo implementan (perro y pez)

import AnimalInterface from "./AnimalInterface";

class Dog implements AnimalInterface {
  eat() {
    console.log('eating...')
  }

  run() {
    console.log('running...')
  }
}

import AnimalInterface from "./AnimalInterface";

class Fish implements AnimalInterface {
  eat() {
    console.log('eating...')
  }

  run() {
    throw new Error('Method not implemented')
  }
}

Como se puede ver estamos haciendo una mala implementación del principio pues estamos creando una interfaz que no cumple con los requisitos de que todas las clases estén implementando sus métodos.

Ejemplo de implementación CORRECTA del principio de segregación de interfaces.

En este ejemplo vamos a tomar el caso base anterior y vamos a solucionarlo utilizando correctamente los principios.

En vista de que no todos los animales pueden correr, como los peces en el caso anterior, vamos a dividir la interfaz animal en dos partes:

export default interface EatInterface {
  eat();
}

export default interface RunInterface {
  run();
}

Ahora implementaremos las interfaces dependiendo de la clase que estemos creando. En este caso, como los peces no pueden correr, no implementaremos RunInterface, pero como si pueden comer implementaremos EatInterface.

En el caso de los perros como pueden comer y correr implementaremos ambas clases:

import EatInterface from "./EatInterface";

class Fish implements EatInterface {
  eat() {
    console.log('eating...')
  }
}

import EatInterface from "./EatInterface";
import RunInterface from "./RunInterface";

class Dog implements EatInterface, RunInterface {
  eat() {
    console.log('eating...')
  }
  run() {
    console.log('running...')
  }
}

Este post forma parte de nuestra serie dedicada a los Principios SOLID, donde cada principio es una pieza clave en la construcción de un código más limpio y profesional. Anteriormente estuvimos hablando del tercer principio, Liskov Substitution Principle.

En las próximas semanas, nos adentraremos en el último de estos principios, cerrando así nuestra serie con una comprensión integral de estas prácticas esenciales en la programación orientada a objetos. Mantente atento para ese próximo capítulo y, mientras tanto, te animamos a aplicar lo aprendido y a seguir elevando la calidad de tu código.