Interfaces: usándolas con clases

Las interfaces en TypeScript no solo sirven para definir contratos para objetos simples, sino que también pueden ser implementadas por clases completas, lo que nos permite crear estructuras más robustas y flexibles en nuestros programas. Cuando una clase implementa una interfaz, está comprometiéndose a cumplir con un conjunto específico de propiedades y métodos, lo que facilita que diferentes clases compartan comportamientos comunes y puedan ser tratadas de manera uniforme.

Imaginemos que definimos una interfaz llamada Shape para representar formas geométricas. Esta interfaz podría incluir propiedades como el número de lados, que sería de solo lectura porque cambiarlo implicaría que la forma es otra distinta. Además, incluiría métodos para calcular el área y el perímetro de la figura. Así, cualquier clase que implemente Shape deberá proporcionar estas propiedades y métodos, garantizando que se comporta como una forma geométrica.

interface Shape {
  readonly sides: number;
  area(): number;
  perimeter(): number;
}

Ahora, si queremos representar un rectángulo, podemos crear una clase Rectangle que implemente esta interfaz. Para simplificar la declaración de propiedades, podemos aprovechar una característica de TypeScript que permite definir y asignar propiedades directamente en el constructor usando modificadores de acceso como readonly o private. Esto nos ahorra tener que declarar las propiedades por separado.

class Rectangle implements Shape {
  constructor(
    public readonly width: number,
    public readonly height: number
  ) {}

  get sides(): number {
    return 4;
  }

  area(): number {
    return this.width * this.height;
  }

  perimeter(): number {
    return 2 * this.width + 2 * this.height;
  }
}

Al implementar la interfaz Shape, nuestra clase Rectangle se convierte en un tipo que puede ser utilizado donde se espere un Shape. Por ejemplo, si tenemos una función process que acepta un objeto de tipo Shape, podremos pasarle un Rectangle sin problemas, ya que cumple con el contrato definido por la interfaz.

function process(shape: Shape) {
  console.log(`Sides: ${shape.sides}`);
  console.log(`Area: ${shape.area()}`);
  console.log(`Perimeter: ${shape.perimeter()}`);
}

const rect = new Rectangle(10, 5);
process(rect);

Dentro de la función process, solo podemos acceder a las propiedades y métodos definidos en la interfaz Shape, lo que limita el conocimiento que tenemos sobre el objeto y promueve la abstracción. No podemos acceder a propiedades específicas de Rectangle como width o height, ya que la función solo sabe que está trabajando con un Shape. Esto es un ejemplo claro de encapsulación y abstracción, principios fundamentales de la programación orientada a objetos que nos ayudan a escribir código más limpio y mantenible.

Además, una clase puede implementar múltiples interfaces separándolas por comas, lo que le permite adoptar múltiples roles o comportamientos según sea necesario. Esto hace que las instancias de una clase sean agentes múltiples, capaces de adaptarse a diferentes contextos sin perder su identidad principal.

Por último, aunque en este ejemplo hemos trabajado con una interfaz sencilla y una clase concreta, las interfaces también pueden especializarse y combinarse con la herencia de clases para crear jerarquías más complejas y flexibles. Esto abre un abanico de posibilidades para diseñar sistemas que sean tanto robustos como fáciles de extender y mantener.