Programación Orientada a Objetos en JavaScript: Clases, Herencia y Encapsulación

La Programación Orientada a Objetos (POO) es un paradigma de programación que nos permite estructurar nuestro código de una manera más organizada y modular. En JavaScript, aunque su naturaleza es prototípica, las clases introducidas en ES6 (ECMAScript 2015) nos proporcionan una sintaxis más familiar y similar a otros lenguajes orientados a objetos, facilitando la implementación de patrones de diseño POO.

Este tutorial te sumergirá en los pilares de la POO en JavaScript, desde la creación de clases hasta la gestión de relaciones de herencia y la importancia de la encapsulación.

¿Por Qué POO en JavaScript? 🤔

Aunque JavaScript tradicionalmente ha manejado la herencia a través de prototipos, la sintaxis de class ofrece una forma más clara y concisa de definir blueprints para objetos. Adoptar POO en JavaScript trae consigo varios beneficios:

• Modularidad: Divide tu aplicación en componentes más pequeños y manejables (objetos).
• Reusabilidad: Las clases permiten crear código reutilizable, evitando la duplicación.
• Mantenibilidad: El código organizado es más fácil de entender, depurar y mantener.
• Escalabilidad: Facilita la expansión de aplicaciones complejas.

Los Cuatro Pilares de la POO 🏗️

Antes de sumergirnos en el código, es crucial entender los cuatro pilares fundamentales de la POO:

1. Encapsulación: Agrupar datos (propiedades) y métodos que operan sobre esos datos dentro de una sola unidad (clase), ocultando los detalles internos de implementación.
2. Herencia: Permite que una clase (subclase) herede propiedades y métodos de otra clase (superclase), promoviendo la reutilización de código.
3. Polimorfismo: La capacidad de objetos de diferentes clases para responder a la misma llamada de método de manera diferente, según su propia implementación.
4. Abstracción: Mostrar solo la información relevante y ocultar los detalles de implementación complejos al usuario.

Clases en JavaScript: El Blueprint 📝

En JavaScript, una clase es una plantilla para crear objetos. Encapsula datos con código para trabajar en esos datos. Usamos la palabra clave class para declarar una clase.

Definición Básica de una Clase

Veamos cómo definir una clase simple para representar un Coche:

class Coche {
  // El constructor es un método especial que se ejecuta cuando se crea una nueva instancia de la clase.
  constructor(marca, modelo, año) {
    this.marca = marca; // 'this' se refiere a la instancia actual del objeto.
    this.modelo = modelo;
    this.año = año;
    this.velocidad = 0;
  }

  // Métodos de la clase
  acelerar(cantidad) {
    this.velocidad += cantidad;
    console.log(`El ${this.marca} ${this.modelo} acelera a ${this.velocidad} km/h.`);
  }

  frenar(cantidad) {
    this.velocidad -= cantidad;
    if (this.velocidad < 0) this.velocidad = 0;
    console.log(`El ${this.marca} ${this.modelo} frena a ${this.velocidad} km/h.`);
  }

  mostrarInfo() {
    console.log(`Coche: ${this.marca} ${this.modelo}, Año: ${this.año}, Velocidad: ${this.velocidad} km/h.`);
  }
}

Creación de Instancias (Objetos)

Una vez que tenemos una clase, podemos crear múltiples objetos a partir de ella, conocidos como instancias. Usamos la palabra clave new para instanciar un objeto:

const miCoche = new Coche('Toyota', 'Corolla', 2020);
const otroCoche = new Coche('Ford', 'Focus', 2022);

miCoche.mostrarInfo(); // Coche: Toyota Corolla, Año: 2020, Velocidad: 0 km/h.
otroCoche.mostrarInfo(); // Coche: Ford Focus, Año: 2022, Velocidad: 0 km/h.

miCoche.acelerar(50);
miCoche.frenar(10);
miCoche.mostrarInfo(); // Coche: Toyota Corolla, Año: 2020, Velocidad: 40 km/h.

Métodos Estáticos

Los métodos estáticos pertenecen a la clase misma, no a las instancias de la clase. Se llaman directamente desde la clase y no pueden acceder a las propiedades this de una instancia. Son útiles para funciones de utilidad que no requieren el estado de un objeto particular.

class Calculadora {
  static sumar(a, b) {
    return a + b;
  }

  static restar(a, b) {
    return a - b;
  }
}

console.log(Calculadora.sumar(5, 3)); // 8
console.log(Calculadora.restar(10, 4)); // 6

// const calc = new Calculadora();
// calc.sumar(1, 2); // Esto daría un error, sumar no es un método de instancia.

Herencia: Reutilización de Código 🧬

La herencia permite crear nuevas clases que extienden funcionalidades de clases existentes. Esto es fundamental para la reutilización de código y para modelar relaciones de tipo "es un" (e.g., un Camión es un Vehículo).

La palabra clave extends

Usamos extends para indicar que una clase hereda de otra. La clase de la que se hereda se llama clase padre, superclase o clase base, y la clase que hereda se llama clase hija, subclase o clase derivada.

Continuando con nuestro ejemplo de Coche, podemos crear una clase Deportivo que herede de Coche y añada funcionalidades específicas.

class Deportivo extends Coche {
  constructor(marca, modelo, año, turboActivado) {
    // Llama al constructor de la clase padre (Coche)
    super(marca, modelo, año);
    this.turboActivado = turboActivado;
  }

  activarTurbo() {
    if (!this.turboActivado) {
      this.turboActivado = true;
      console.log(`El ${this.marca} ${this.modelo} activa el turbo. ¡Máxima potencia!`);
      this.velocidad += 30; // Un extra de velocidad al activar el turbo
    } else {
      console.log('El turbo ya está activado.');
    }
  }

  // Sobreescribir un método de la clase padre
  acelerar(cantidad) {
    // Podemos llamar al método del padre usando super.metodo()
    super.acelerar(cantidad * (this.turboActivado ? 1.5 : 1)); // Acelera más si el turbo está activo
    console.log(`Deportivo acelera con su toque especial.`);
  }
}

const miDeportivo = new Deportivo('Ferrari', 'F8 Tributo', 2023, false);
miDeportivo.mostrarInfo(); // Coche: Ferrari F8 Tributo, Año: 2023, Velocidad: 0 km/h.
miDeportivo.acelerar(60); // Deportivo acelera con su toque especial.
miDeportivo.mostrarInfo(); // Coche: Ferrari F8 Tributo, Año: 2023, Velocidad: 60 km/h.
miDeportivo.activarTurbo(); // El Ferrari F8 Tributo activa el turbo. ¡Máxima potencia!
miDeportivo.acelerar(20); // Deportivo acelera con su toque especial.
miDeportivo.mostrarInfo(); // Coche: Ferrari F8 Tributo, Año: 2023, Velocidad: 120 km/h.

La palabra clave super

La palabra clave super se utiliza en dos contextos principales dentro de una clase hija:

1. super(): Para llamar al constructor de la clase padre. Es obligatorio llamarlo en el constructor de la subclase si esta tiene su propio constructor y hereda de otra clase. Debe ser la primera instrucción en el constructor de la subclase.
2. super.metodo(): Para llamar a un método de la clase padre. Esto es útil cuando quieres extender o modificar la funcionalidad de un método padre sin reescribirlo completamente.

Encapsulación: Protegiendo tus Datos 🔒

La encapsulación es el principio de agrupar los datos (propiedades) y los métodos que operan sobre esos datos en una sola unidad (la clase), y restringir el acceso directo a algunos de los componentes del objeto. El objetivo es prevenir la modificación accidental de los datos internos y hacer que la clase sea más robusta.

Tradicionalmente, JavaScript no tenía modificadores de acceso como private o protected como en otros lenguajes (Java, C++). Sin embargo, con las propiedades de clase privadas (#) introducidas en ES2020, ahora tenemos una forma nativa de encapsular propiedades.

Propiedades de Clase Privadas (#)

Las propiedades y métodos privados se declaran prefijándolos con #. Solo se puede acceder a ellos desde dentro de la clase que los define.

class CuentaBancaria {
  #saldo;
  #titular;

  constructor(titular, saldoInicial) {
    this.#titular = titular;
    this.#saldo = saldoInicial;
  }

  depositar(cantidad) {
    if (cantidad > 0) {
      this.#saldo += cantidad;
      console.log(`Depósito de ${cantidad} realizado. Nuevo saldo: ${this.#saldo}`);
    } else {
      console.log('La cantidad a depositar debe ser positiva.');
    }
  }

  retirar(cantidad) {
    if (cantidad > 0 && cantidad <= this.#saldo) {
      this.#saldo -= cantidad;
      console.log(`Retiro de ${cantidad} realizado. Nuevo saldo: ${this.#saldo}`);
    } else if (cantidad > this.#saldo) {
      console.log('Fondos insuficientes.');
    } else {
      console.log('La cantidad a retirar debe ser positiva.');
    }
  }

  getSaldo() {
    return this.#saldo;
  }

  getTitular() {
    return this.#titular;
  }
}

const miCuenta = new CuentaBancaria('Alice', 1000);
console.log(miCuenta.getSaldo()); // 1000
console.log(miCuenta.getTitular()); // Alice

miCuenta.depositar(200);
miCuenta.retirar(500);
miCuenta.retirar(1000); // Fondos insuficientes.

// console.log(miCuenta.#saldo); // Esto generaría un error de sintaxis: Private field '#saldo' must be declared in an enclosing class

Getters y Setters (Accesor y Mutador)

Incluso antes de las propiedades privadas, los getters y setters eran y siguen siendo una forma común de controlar cómo se accede y se modifica el estado interno de un objeto. Permiten añadir lógica de validación o transformación antes de que una propiedad sea leída o escrita.

class Persona {
  constructor(nombre, edad) {
    this._nombre = nombre; // Convención para indicar que es una propiedad "privada" (no estricta)
    this._edad = edad;
  }

  // Getter para nombre
  get nombre() {
    return this._nombre.toUpperCase(); // Devuelve el nombre en mayúsculas
  }

  // Setter para nombre
  set nombre(nuevoNombre) {
    if (typeof nuevoNombre === 'string' && nuevoNombre.length > 2) {
      this._nombre = nuevoNombre;
    } else {
      console.log('El nombre debe ser una cadena de al menos 3 caracteres.');
    }
  }

  // Getter para edad
  get edad() {
    return this._edad;
  }

  // Setter para edad
  set edad(nuevaEdad) {
    if (typeof nuevaEdad === 'number' && nuevaEdad > 0) {
      this._edad = nuevaEdad;
    } else {
      console.log('La edad debe ser un número positivo.');
    }
  }
}

const p = new Persona('Carlos', 30);
console.log(p.nombre); // CARLOS (el getter transforma el valor)
p.nombre = 'Ana';
console.log(p.nombre); // ANA
p.nombre = 'Jo'; // El setter previene la asignación
console.log(p.nombre); // ANA (el nombre no cambió)

p.edad = 25;
console.log(p.edad); // 25
p.edad = -5; // El setter previene la asignación
console.log(p.edad); // 25 (la edad no cambió)

Los getters y setters, aunque no proporcionan una encapsulación estricta como las propiedades privadas (#), son excelentes para controlar el acceso y mutación de las propiedades internas, añadiendo una capa de lógica.

Polimorfismo: Múltiples Formas, Un Comportamiento 🎭

El polimorfismo, el tercer pilar de la POO, significa "muchas formas". En el contexto de las clases, se refiere a la capacidad de diferentes objetos para responder de manera diferente a la misma llamada de método. Esto se logra principalmente a través de la sobreescritura de métodos.

Consideremos un ejemplo con una clase base Animal y varias subclases.

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

  emitirSonido() {
    console.log(`${this.nombre} hace un sonido genérico.`);
  }
}

class Perro extends Animal {
  constructor(nombre, raza) {
    super(nombre);
    this.raza = raza;
  }

  emitirSonido() {
    console.log(`${this.nombre} ladra: ¡Guau guau!`);
  }

  jugar() {
    console.log(`${this.nombre} (${this.raza}) está jugando.`);
  }
}

class Gato extends Animal {
  constructor(nombre, color) {
    super(nombre);
    this.color = color;
  }

  emitirSonido() {
    console.log(`${this.nombre} maúlla: ¡Miau!`);
  }

  ronronear() {
    console.log(`${this.nombre} está ronroneando.`);
  }
}

const animales = [
  new Animal('Bicho'),
  new Perro('Max', 'Labrador'),
  new Gato('Pelusa', 'Blanco')
];

for (const animal of animales) {
  animal.emitirSonido(); // Cada objeto responde de manera diferente a la misma llamada
}

/* Salida esperada:
Bicho hace un sonido genérico.
Max ladra: ¡Guau guau!
Pelusa maúlla: ¡Miau!
*/

En este ejemplo, todos los objetos son de tipo Animal o de una clase que hereda de Animal. Sin embargo, cuando se llama al método emitirSonido(), cada objeto se comporta según su propia implementación de ese método. Esto es polimorfismo en acción: la misma interfaz (emitirSonido) con diferentes implementaciones.

Ventajas del Polimorfismo

• Flexibilidad: Permite escribir código más genérico que puede trabajar con objetos de diferentes tipos de manera uniforme.
• Extensibilidad: Es fácil añadir nuevas clases que extiendan la clase base y proporcionen sus propias implementaciones polimórficas sin modificar el código existente.
• Simplicidad: Reduce la necesidad de usar múltiples sentencias if-else o switch para manejar diferentes tipos de objetos.

Abstracción: Simplificando la Complejidad 🤯

La abstracción se centra en mostrar solo los detalles esenciales y ocultar la complejidad interna. En JavaScript, la abstracción se logra a menudo a través de la encapsulación (ocultando detalles de implementación con propiedades privadas) y mediante el diseño de interfaces claras para las clases y sus métodos.

Aunque JavaScript no tiene clases abstractas o interfaces formales como Java o TypeScript, podemos simular la abstracción:

• Definiendo una clase base con métodos que deben ser implementados por las subclases. Podemos hacer que un método en la clase base lance un error si no es sobreescrito, forzando así la implementación en las subclases.
• Uso de propiedades privadas para ocultar la lógica interna.

class Forma {
  constructor(nombre) {
    this.nombre = nombre;
  }

  calcularArea() {
    throw new Error('El método calcularArea() debe ser implementado por las subclases.');
  }

  mostrarInfo() {
    console.log(`Esta es una forma llamada ${this.nombre}.`);
  }
}

class Circulo extends Forma {
  constructor(nombre, radio) {
    super(nombre);
    this.radio = radio;
  }

  calcularArea() {
    return Math.PI * this.radio ** 2;
  }
}

class Rectangulo extends Forma {
  constructor(nombre, ancho, alto) {
    super(nombre);
    this.ancho = ancho;
    this.alto = alto;
  }

  calcularArea() {
    return this.ancho * this.alto;
  }
}

// const formaGenerica = new Forma('Desconocida');
// formaGenerica.calcularArea(); // Lanza un error, ya que no se implementó

const miCirculo = new Circulo('Círculo Rojo', 5);
console.log(`Área del ${miCirculo.nombre}: ${miCirculo.calcularArea().toFixed(2)}`); // Área del Círculo Rojo: 78.54
miCirculo.mostrarInfo(); // Esta es una forma llamada Círculo Rojo.

const miRectangulo = new Rectangulo('Rectángulo Azul', 10, 4);
console.log(`Área del ${miRectangulo.nombre}: ${miRectangulo.calcularArea()}`); // Área del Rectángulo Azul: 40

Aquí, Forma es una clase abstracta conceptual. No tiene sentido instanciarla directamente porque calcularArea no tiene una implementación genérica. Obliga a sus subclases a proporcionar su propia lógica para calcularArea.

Patrones de Diseño Comunes con POO en JavaScript ✨

Comprender los principios de la POO te abre la puerta a implementar patrones de diseño que resuelven problemas comunes de software de manera eficiente y reutilizable.

Patrón Singleton

El patrón Singleton asegura que una clase tenga solo una instancia y proporciona un punto de acceso global a ella. Es útil para recursos únicos como una conexión a una base de datos o un gestor de configuración.

class ConfigurationManager {
  constructor() {
    if (ConfigurationManager.instance) {
      return ConfigurationManager.instance;
    }
    this.settings = { theme: 'dark', language: 'es' };
    ConfigurationManager.instance = this;
  }

  getSetting(key) {
    return this.settings[key];
  }

  setSetting(key, value) {
    this.settings[key] = value;
  }
}

const config1 = new ConfigurationManager();
const config2 = new ConfigurationManager();

console.log(config1 === config2); // true, ambas referencias apuntan a la misma instancia
console.log(config1.getSetting('theme')); // dark
config2.setSetting('language', 'en');
console.log(config1.getSetting('language')); // en

Patrón Factory

El patrón Factory proporciona una interfaz para crear objetos en una superclase, pero permite a las subclases alterar el tipo de objetos que se crearán. Es útil cuando el proceso de creación de objetos es complejo o depende de la lógica de negocio.

class Soldado {
  constructor(nombre) {
    this.nombre = nombre;
    this.tipo = 'Soldado genérico';
  }

  atacar() {
    return `${this.nombre} ataca.`;
  }
}

class Arquero extends Soldado {
  constructor(nombre) {
    super(nombre);
    this.tipo = 'Arquero';
  }
  atacar() {
    return `${this.nombre} lanza una flecha.`;
  }
}

class Caballero extends Soldado {
  constructor(nombre) {
    super(nombre);
    this.tipo = 'Caballero';
  }
  atacar() {
    return `${this.nombre} carga con su espada.`;
  }
}

class UnidadMilitarFactory {
  crearUnidad(tipo, nombre) {
    switch (tipo) {
      case 'arquero':
        return new Arquero(nombre);
      case 'caballero':
        return new Caballero(nombre);
      default:
        return new Soldado(nombre);
    }
  }
}

const factory = new UnidadMilitarFactory();
const unidad1 = factory.crearUnidad('arquero', 'Legolas');
const unidad2 = factory.crearUnidad('caballero', 'Arturo');
const unidad3 = factory.crearUnidad('general', 'Comandante');

console.log(unidad1.atacar()); // Legolas lanza una flecha.
console.log(unidad2.atacar()); // Arturo carga con su espada.
console.log(unidad3.atacar()); // Comandante ataca.

¿Cuándo Usar POO en JavaScript? 🎯

La POO no es una solución mágica para todos los problemas, pero es especialmente útil en los siguientes escenarios:

• Aplicaciones grandes y complejas: Donde la organización del código es crucial para la mantenibilidad.
• Trabajo en equipo: Facilita que múltiples desarrolladores trabajen en diferentes partes de la codebase sin conflictos.
• Requisitos cambiantes: El código modular y extensible es más fácil de adaptar a nuevas funcionalidades.
• Modelado de entidades del mundo real: Si tu aplicación necesita representar objetos con estados y comportamientos complejos (usuarios, productos, pedidos, etc.).

Tabla Comparativa: Enfoque Procedural vs. POO

Conclusión ✨

Dominar la Programación Orientada a Objetos en JavaScript te equipa con herramientas poderosas para escribir código más limpio, modular y mantenible. Desde la definición de clases y la gestión de la herencia hasta la implementación de la encapsulación con propiedades privadas y el aprovechamiento del polimorfismo, los principios de la POO son fundamentales para construir aplicaciones robustas y escalables. Al aplicar estos conceptos, no solo mejorarás la calidad de tu código, sino que también te prepararás para entender y utilizar frameworks y librerías modernas de JavaScript que hacen un uso intensivo de la POO.

¡Sigue practicando y aplicando estos conceptos en tus propios proyectos para solidificar tu aprendizaje! La POO es una habilidad invaluable en el mundo del desarrollo de software.