Clase abstracta de JavaScript

1. Clase abstracta de JavaScript
2. Ampliar la clase abstracta con clases concretas
3. Conclusión

Se deben considerar dos conceptos principales cuando se trabaja con clases abstractas de JavaScript: abstracción y herencia.

A través de la abstracción, habilita la seguridad, ocultando detalles específicos y mostrando solo la información esencial de un objeto, mientras que la herencia toma propiedades de otra clase y crea una relación padre-hijo entre ellas.

Clase abstracta de JavaScript

Una clase abstracta es una clase que contiene uno o más métodos abstractos pero que no puede instanciar. Las clases abstractas no pueden ser instanciadas pero pueden extenderse usando métodos.

Además, las clases abstractas deben heredarse, lo que requiere clases o subclases concretas para extender la clase abstracta con los métodos declarados dentro de ella.

Los métodos abstractos son métodos que solo se pueden declarar pero no tienen implementación.

Primero, podemos definir una clase abstracta y crear un constructor dentro de ella. Después de eso, debemos definir las funciones al extender la clase abstracta.

Para este ejemplo, hemos definido Fruit como el nombre de la clase abstracta y hemos creado dos métodos dentro de él: color() para indicar el color de la fruta y eat() para averiguar si la fruta se ha consumido o no.

Dado que todas las frutas que hemos tomado aquí como ejemplos se pueden consumir, implementamos el método para mostrarlas como comer dentro de la clase abstracta. Pero cuando definimos cada clase concreta, debemos implementar el método color() para cada una de ellas.

class Fruit {
  constructor() {
    if (this.constructor == Fruit) {
      throw new Error('Abstract classes can\'t be instantiated.');
    }
  }

  color() {
    throw new Error('Method \'color()\' must be implemented.');
  }

  eat() {
    console.log('eating');
  }
}

Ampliar la clase abstracta con clases concretas

Después de crear la clase abstracta, tenemos que crear clases concretas. Al construir clases concretas, debemos hacer que hereden todas las funciones y el comportamiento de la clase abstracta.

El fragmento a continuación muestra las clases concretas Apple y Orange creadas para la clase abstracta. Usando la palabra clave extiende, realiza la herencia.

class Apple extends Fruit {
  color() {
    console.log('Red');
  }
}

class Orange extends Fruit {
  color() {
    console.log('Orange');
  }
}

Al definir clases abstractas y clases concretas, se han logrado la abstracción y la herencia.

El código completo consiste en combinar los fragmentos de código anteriores y el código completo con el resultado que se muestra en las figuras. Aquí, ambas clases concretas se denominan clase abstracta, que muestra la salida implementada en los métodos.

Aparte de eso, cuando el constructor tiene el mismo nombre que la clase abstracta, arroja un error. Pero al instanciar con las clases concretas, funciona perfectamente.

Código:

// Abstract Class 'Fruit'.
class Fruit {
  constructor() {
    if (this.constructor == Fruit) {
      throw new Error('Abstract classes can\'t be instantiated.');
    }
  }
  // Method 'color'
  color() {
    throw new Error('Method \'color()\' must be implemented.');
  }
  // Method 'eat'
  eat() {
    console.log('eating');
  }
}

// Concrete class 'Apple'
class Apple extends Fruit {
  color() {
    console.log('Red');
  }
}

// Concrete class 'Orange'
class Orange extends Fruit {
  color() {
    console.log('Orange');
  }
}
// Calling the classes
new Apple().eat();
new Orange().eat();
new Apple().color();
new Orange().color();

Producción:

Incluso la clase concreta Apple ha implementado el método color() dentro de ella, pero banana() no. Por lo tanto, la clase concreta banana() hereda solo las propiedades de la clase abstracta.

Entonces, cuando el método color() llama, banana arroja un error en lugar de imprimir el color.

El siguiente fragmento de código representa en gran medida el concepto de herencia.

// Abstract class 'Fruit'
class Fruit {
  constructor() {
    if (this.constructor == Fruit) {
      throw new Error('Abstract classes can\'t be instantiated.');
    }
  }

  // Method 'color'
  color() {
    throw new Error('Method \'color()\' must be implemented.');
  }

  // Method 'eat'
  eat() {
    console.log('eating');
  }
}

// Concrete class 'Apple'
class Apple extends Fruit {
  color() {
    console.log('Red');
  }
}

// Concrete class 'Banana'
class Banana extends Fruit {}

// Calling the classes
new Apple().eat();
new Banana().eat();
new Apple().color();
new Banana().color();

Producción:

Aparte, crear una instancia también arroja un error. Como las clases abstractas no se pueden instanciar, no podemos llamarlas.

Código:

// Abstract class 'Fruit'
class Fruit {
  constructor() {
    if (this.constructor == Fruit) {
      throw new Error('Abstract classes can\'t be instantiated.');
    }
  }

  // Method 'color'
  color() {
    throw new Error('Method \'color()\' must be implemented.');
  }

  // Method 'eat'
  eat() {
    console.log('eating');
  }
}
// Concrete class 'Apple'
class Apple extends Fruit {
  color() {
    console.log('Red');
  }
}
// Calling the class
new Fruit();

Producción:

Conclusión

En general, contar con esta característica de abstracción en JavaScript y otros lenguajes de programación orientada a objetos mejora la comprensión y la capacidad de mantenimiento del código para el desarrollador y el lector y reduce la duplicación de código.