Programación Orientada a Objetos en JavaScript

La programación orientada a objetos (POO) es un paradigma de programación que se enfoca en el uso de objetos y sus interacciones para modelar y resolver problemas de la vida real.

En JavaScript, cada objeto tiene un prototipo, que es otro objeto del que hereda propiedades y métodos. Esto permite a los objetos compartir comportamiento entre sí de manera eficiente, en lugar de tener que definir todas sus propiedades y métodos individualmente.
Por ejemplo, podemos crear un objeto person que tenga un prototipo personProto:

const personProto = {
  greet() {
    console.log('Hello!');
  },
};

const person = Object.create(personProto);

En este caso, el objeto person hereda el método greet() del objeto personProto. Luego, podemos llamar al método greet() en el objeto person:

person.greet(); // Hello!

La POO se basa en cuatro principios fundamentales: abstracción, encapsulamiento, herencia y polimorfismo.

• Abstracción
  En JavaScript se refiere a la habilidad de un programa para manipular y trabajar con objetos de manera genérica, sin tener que conocer los detalles de su implementación concreta. Esto permite escribir código que se pueda aplicar a diferentes tipos de objetos, y no solo a uno en particular.
  Sería como tomar lo esencial o estrictamente necesario de un objeto para luego, a partir de este, crear otros y agregar características. De acuerdo a esto, lo “esencial” varía de acuerdo al contexto o finalidad de la aplicación que se realiza

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} hace un sonido.`);
  }
}

En el ejemplo (muy muy simple) se puede ver que lo más básico que necesitaría es un nombre para un animal y un método “speak” para luego a partir de estos crear otros animales en otras clases. Lo verán más adelante en la herencia.

• Encapsulamiento
  Es un principio de programación que consiste en ocultar los detalles de implementación de una clase o objeto, y exponer solo la interfaz necesaria para que otros componentes puedan interactuar con él. De esta manera, se garantiza que los componentes dependan solo de la interfaz de la clase o objeto, y no de su implementación concreta.

    Para acceder a estas propiedades y métodos "ocultos" se pueden usar getters y setters
  
    **Los getters** son funciones que se utilizan para obtener el valor de una propiedad de un objeto
  
    **Los setters** son funciones que se utilizan para establecer un nuevo valor para una propiedad de un objeto.**		
  

• Herencia
  Es un concepto de programación orientada a objetos que permite que una clase adquiera las propiedades y comportamientos de otra clase. En JavaScript, la herencia se logra mediante el uso de la palabra clave ** extends** y permite que una clase hija herede las propiedades y métodos de una clase padre.

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} hace un sonido.`);
  }
}
class Dog extends Animal {
  constructor(name, type) {
    super(name);
    this.type = type;
  }
}

En el ejemplo la clase Dog toma el método “speak” y la propiedad “name” de la clase Animal y adicionalmente añade otra propiedad “type”

• Polimorfismo
  Es un concepto de la programación orientada a objetos que se refiere a la habilidad de una función o método para tratar objetos de diferentes tipos de manera diferente. Esto permite a una función o método tener comportamientos diferentes dependiendo del tipo de objeto con el que se llame.
  En JavaScript, el polimorfismo se puede lograr mediante la herencia y la sobrecarga de métodos. La herencia se refiere a la capacidad de una clase hija de heredar las propiedades y métodos de una clase padre, y luego modificarlos o extenderlos para adaptarse a sus necesidades. La sobrecarga de métodos se refiere a la capacidad de una clase de tener múltiples implementaciones de un mismo método, con diferentes parámetros o tipos de retorno.

Ejemplo de sobrecarga:

Tenemos una clase Calculator que tiene un método add() que recibe dos números y devuelve su suma:

class Calculator {
  add(a, b) {
    return a + b;
  }
}

Luego, podemos agregar otra implementación de add() que recibe un solo número y devuelve ese número incrementado en uno:

class Calculator {
  add(a, b) {
    return a + b;
  }

  add(a) {
    return a + 1;
  }
}

En este caso la clase puede ejecutar el método “add” de dos formas para así obtener distintos resultados.

Ejemplo de Polimorfismo de reemplazo:
Mantenemos la clase Animal con su método “speak”

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

Luego al crear la clase Dog podemos modificar el comportamiento del método “speak” para obtener otro resultado

class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  speak() {
    console.log(`${this.name} barks.`);
  }
}