PROGRAMACIÓN ORIENTADA A OBJETOS EN JAVASCRIPT

La Programación Orientada a Objetos (POO) es un paradigma de programación que organiza el código en torno a objetos, que son instancias de clases que encapsulan datos (propiedades) y comportamientos (métodos). JavaScript, aunque originalmente no estaba diseñado específicamente para POO, soporta este paradigma de forma robusta gracias a sus características modernas como clases (introducidas en ES6) y prototipos. En este post, se exploran los conceptos fundamentales de la programación orientada a objetos en Javascript y con un un ejemplo sencillo.

Para declarar métodos privados hay que poner "#"

class MiClase {
  // Método público
  metodoPublico() {
    console.log("Este es un método público");
    this.#metodoPrivado(); // Llamada al método privado
  }

  // Método privado
  #metodoPrivado() {
    console.log("Este es un método privado");
  }
}

Para declarar atributos privados hay que poner "#"

class MiClase {
  #atributoPrivado; // Declaración de atributo privado
  atributoPublico; // Declaración de atributo púbico
  constructor(valor) {
    this.#atributoPrivado = valor; // Inicialización
  }

  // Método para acceder al atributo privado
  getAtributoPrivado() {
    return this.#atributoPrivado;
  }

  // Método para modificar el atributo privado
  setAtributoPrivado(nuevoValor) {
    this.#atributoPrivado = nuevoValor;
  }
}

En JavaScript, los métodos estáticos en Programación Orientada a Objetos (POO) se declaran utilizando la palabra clave static dentro de una clase. Estos métodos pertenecen a la clase en sí, no a las instancias de la clase, lo que significa que no necesitas crear un objeto de la clase para llamarlos. A continuación, te explico cómo declararlos y usarlos:
```
class Calculadora {
  // Método estático
  static sumar(a, b) {
    return a + b;
  }

  // Otro método estático
  static multiplicar(a, b) {
    return a * b;
  }
}

// Llamada a métodos estáticos sin instanciar la clase
console.log(Calculadora.sumar(5, 3)); // Output: 8
console.log(Calculadora.multiplicar(4, 2)); // Output: 8
```

Conceptos Clave de la Programación Orientada a Objetos en JavaScript

Clases y Objetos: Una clase es una plantilla que define la estructura y comportamiento de los objetos. Un objeto es una instancia de una clase.
Encapsulamiento: Permite ocultar los detalles internos de un objeto y exponer solo lo necesario mediante métodos públicos. En JavaScript, se logra con variables privadas y métodos.
Herencia: Permite que una clase derive de otra, heredando sus propiedades y métodos. En JavaScript, se usa extends para implementar herencia.
Polimorfismo: Permite que diferentes clases implementen métodos con el mismo nombre pero con comportamientos distintos.
Abstracción: Simplifica sistemas complejos al modelar solo los aspectos relevantes de un objeto.

JavaScript implementa la POO principalmente a través de prototipos y, desde ES6, con una sintaxis de clases más clara y similar a otros lenguajes orientados a objetos.
Ejemplo:

// Clase base: Vehiculo
class Vehiculo {
  #velocidad; // Propiedad privada

  constructor(marca, modelo) {
    this.marca = marca;
    this.modelo = modelo;
    this.#velocidad = 0; // Inicializamos la velocidad en 0
  }

  // Método para acelerar
  acelerar(incremento) {
    this.#velocidad += incremento;
    return `${this.marca} ${this.modelo} acelera a ${this.#velocidad} km/h`;
  }

  // Método para frenar
  frenar() {
    this.#velocidad = 0;
    return `${this.marca} ${this.modelo} se ha detenido`;
  }

  // Getter para obtener la velocidad
  getVelocidad() {
    return this.#velocidad;
  }

  // Método que será sobrescrito (polimorfismo)
  describir() {
    return `Vehículo: ${this.marca} ${this.modelo}`;
  }
}

// Clase derivada: Coche
class Coche extends Vehiculo {
  constructor(marca, modelo, numPuertas) {
    super(marca, modelo); // Llama al constructor de la clase base
    this.numPuertas = numPuertas;
  }

  // Sobrescribimos el método describir (polimorfismo)
  describir() {
    return `Coche: ${this.marca} ${this.modelo} con ${this.numPuertas} puertas`;
  }

  // Método específico de Coche
  activarModoSport() {
    return `${this.marca} ${this.modelo} ha activado el modo sport`;
  }
}

// Uso del sistema
const miCoche = new Coche("Toyota", "Corolla", 4);
console.log(miCoche.describir()); // Coche: Toyota Corolla con 4 puertas
console.log(miCoche.acelerar(50)); // Toyota Corolla acelera a 50 km/h
console.log(miCoche.getVelocidad()); // 50
console.log(miCoche.activarModoSport()); // Toyota Corolla ha activado el modo sport
console.log(miCoche.frenar()); // Toyota Corolla se ha detenido

const miVehiculo = new Vehiculo("Honda", "Civic");
console.log(miVehiculo.describir()); // Vehículo: Honda Civic
console.log(miVehiculo.acelerar(30)); // Honda Civic acelera a 30 km/h

Hasta ahora no me había atrevido con la Programación orientada a objetos en Javascript porque pensaba que era más complicado.