Ejercicios Prácticos

Este conjunto de ejercicios está diseñado para reforzar los conceptos discutidos en el Capítulo 6, enfocándose en los principios de programación orientada a objetos como la encapsulación, abstracción, herencia y el uso de clases ES6 en JavaScript. Cada ejercicio incluye un desafío y una solución para ayudarte a aplicar lo que has aprendido en escenarios prácticos de codificación.

Ejercicio 1: Implementando una Clase con Encapsulación

Crea una clase Person que encapsule el nombre y la edad de un individuo y proporcione métodos para obtener y establecer cada atributo. Asegúrate de que la edad no pueda ser establecida en un número negativo.

Solución:

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    getName() {
        return this.name;
    }

    setName(name) {
        this.name = name;
    }

    getAge() {
        return this.age;
    }

    setAge(age) {
        if (age < 0) {
            throw new Error("Age cannot be negative");
        }
        this.age = age;
    }
}

const person = new Person("John", 30);
console.log(person.getName()); // Outputs: John
console.log(person.getAge()); // Outputs: 30

person.setAge(25);
console.log(person.getAge()); // Outputs: 25

// Attempting to set a negative age
try {
    person.setAge(-5);
} catch (e) {
    console.log(e.message); // Outputs: Age cannot be negative
}

Ejercicio 2: Implementación de Herencia y Sobrescritura de Métodos

Extiende la clase Person para crear una nueva clase llamada Employee que incluya todo de Person y añada employeeId y un método para mostrar todos los detalles del empleado.

Solución:

class Employee extends Person {
    constructor(name, age, employeeId) {
        super(name, age); // Calls the constructor of the base class
        this.employeeId = employeeId;
    }

    display() {
        console.log(`Name: ${this.name}, Age: ${this.age}, Employee ID: ${this.employeeId}`);
    }
}

const employee = new Employee("Alice", 28, "E12345");
employee.display(); // Outputs: Name: Alice, Age: 28, Employee ID: E12345

Ejercicio 3: Usando Métodos Estáticos

Crea una clase Calculator con métodos estáticos para operaciones aritméticas básicas (suma, resta, multiplicación, división) que tomen dos números y devuelvan el resultado.

Solución:

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

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

    static multiply(a, b) {
        return a * b;
    }

    static divide(a, b) {
        if (b === 0) {
            throw new Error("Division by zero");
        }
        return a / b;
    }
}

console.log(Calculator.add(10, 5)); // Outputs: 15
console.log(Calculator.subtract(10, 5)); // Outputs: 5
console.log(Calculator.multiply(10, 5)); // Outputs: 50
console.log(Calculator.divide(10, 5)); // Outputs: 2

Ejercicio 4: Abstracción con Proxies

Crea un proxy para un objeto settings que valide los cambios en las propiedades. Específicamente, asegúrate de que volume esté entre 0 y 100.

Solución:

let settings = {
    volume: 30
};

let settingsProxy = new Proxy(settings, {
    set(target, prop, value) {
        if (prop === 'volume') {
            if (value < 0 || value > 100) {
                throw new Error("Volume must be between 0 and 100");
            }
        }
        target[prop] = value;
        return true;
    }
});

settingsProxy.volume = 90; // Works fine
console.log(settings.volume); // Outputs: 90

// Attempting to set volume out of range
try {
    settingsProxy.volume = 101;
} catch (e) {
    console.log(e.message); // Outputs: Volume must be between 0 and 100
}

Estos ejercicios proporcionan aplicaciones prácticas de las características de programación orientada a objetos discutidas en el Capítulo 6, ayudándote a solidificar tu comprensión de estos conceptos a través de desafíos de codificación que reflejan escenarios del mundo real.