JavaScript: Programación Orientada a Objetos

La programación orientada a objetos (POO) es un paradigma de programación que se basa en el uso de "objetos", que son instancias de "clases". En JavaScript, la POO se ha convertido en una práctica común para desarrollar aplicaciones complejas y mantenibles. A continuación, exploraremos los conceptos fundamentales de la POO en JavaScript, incluyendo clases, herencia, encapsulamiento y polimorfismo.

Clases y objetos

En JavaScript, una clase es una plantilla para crear objetos. Las clases encapsulan datos y comportamientos que son comunes a todos los objetos de ese tipo. Aquí tienes un ejemplo básico de cómo definir una clase y crear un objeto:

class Persona {
    constructor(nombre, edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    saludar() {
        console.log(`Hola, mi nombre es ${this.nombre} y tengo ${this.edad} años.`);
    }
}

const juan = new Persona('Juan', 30);
juan.saludar(); // Salida: Hola, mi nombre es Juan y tengo 30 años.

Herencia

La herencia es un mecanismo que permite a una clase derivar de otra clase, heredando sus propiedades y métodos. En JavaScript, esto se logra utilizando la palabra clave extends. Aquí tienes un ejemplo:

class Empleado extends Persona {
    constructor(nombre, edad, salario) {
        super(nombre, edad);
        this.salario = salario;
    }

    mostrarSalario() {
        console.log(`${this.nombre} tiene un salario de ${this.salario} euros.`);
    }
}

const ana = new Empleado('Ana', 28, 35000);
ana.saludar();         // Salida: Hola, mi nombre es Ana y tengo 28 años.
ana.mostrarSalario();  // Salida: Ana tiene un salario de 35000 euros.

Encapsulamiento

El encapsulamiento es el principio de ocultar los detalles internos de un objeto y exponer solo lo necesario. En JavaScript, podemos lograr encapsulamiento utilizando propiedades privadas, que se definen con el prefijo #:

class CuentaBancaria {
    #saldo = 0;

    constructor(titular) {
        this.titular = titular;
    }

    depositar(cantidad) {
        if (cantidad > 0) {
            this.#saldo += cantidad;
        }
    }

    obtenerSaldo() {
        return this.#saldo;
    }
}

const cuenta = new CuentaBancaria('Carlos');
cuenta.depositar(1000);
console.log(cuenta.obtenerSaldo()); // Salida: 1000

Polimorfismo

El polimorfismo permite utilizar una misma interfaz para diferentes tipos de objetos. En JavaScript, esto se puede lograr mediante la sobreescritura de métodos. Aquí tienes un ejemplo:

class Animal {
    hacerSonido() {
        console.log('El animal hace un sonido.');
    }
}

class Perro extends Animal {
    hacerSonido() {
        console.log('El perro ladra.');
    }
}

class Gato extends Animal {
    hacerSonido() {
        console.log('El gato maúlla.');
    }
}

const animales = [new Animal(), new Perro(), new Gato()];
animales.forEach(animal => animal.hacerSonido());
// Salida:
// El animal hace un sonido.
// El perro ladra.
// El gato maúlla.