Conceptos Básicos de Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) es un enfoque de programación que organiza el software en torno a objetos, que son instancias de clases. Este paradigma permite modelar entidades del mundo real en el software, facilitando la estructura y organización del código. A continuación, se presentan los conceptos clave de la POO:

1. Clases

Una clase es una plantilla para crear objetos. Define el tipo de objeto, incluyendo sus atributos (propiedades) y métodos (funciones). Una clase actúa como un plano que describe cómo se deben crear los objetos y qué características tendrán.

2. Objetos

Un objeto es una instancia de una clase. Representa una entidad concreta en el software con propiedades y comportamientos específicos definidos por su clase. Los objetos interactúan entre sí para realizar tareas en el programa.

3. Atributos

Los atributos son variables que pertenecen a un objeto. Describen las características del objeto, como su estado o propiedades. Por ejemplo, un objeto "Persona" puede tener atributos como "nombre" y "edad".

4. Métodos

Los métodos son funciones que pertenecen a un objeto. Describen los comportamientos del objeto, permitiendo realizar acciones o calcular resultados basados en sus atributos. Por ejemplo, un objeto "Persona" puede tener un método "saludar".

Ejemplo en JavaScript

Vamos a crear una clase sencilla llamada Persona. Esta clase tendrá atributos nombre y edad, y un método saludar. 

// Definición de la clase Persona

class Persona {

  // El constructor se llama cuando se crea un objeto de la clase

  constructor(nombre, edad) {

    this.nombre = nombre; // atributo nombre

    this.edad = edad;     // atributo edad

  }

  // Método saludar

  saludar() {

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

  }

}

// Crear un objeto de la clase Persona

const persona1 = new Persona('Juan', 30);

// Usar el método saludar

persona1.saludar(); // Output: Hola, mi nombre es Juan y tengo 30 años.

En este ejemplo:

• Definimos la clase Persona con el constructor constructor(nombre, edad) para inicializar los atributos nombre y edad.

• Creamos un método saludar que imprime un saludo con el nombre y la edad de la persona.

• Creamos un objeto persona1 de la clase Persona y llamamos al método saludar.

Ejemplo en JAVA

// Definición de la clase Persona

public class Persona {

    // Atributos de la clase

    private String nombre;

    private int edad;

    // Constructor de la clase

    public Persona(String nombre, int edad) {

        this.nombre = nombre; // Asignación del atributo nombre

        this.edad = edad;     // Asignación del atributo edad

    }

    // Método saludar

    public void saludar() {

        System.out.println("Hola, mi nombre es " + this.nombre + " y tengo " + this.edad + " años.");

    }

    // Método main para ejecutar el código

    public static void main(String[] args) {

        // Crear un objeto de la clase Persona

        Persona persona1 = new Persona("Juan", 30);

        // Usar el método saludar

        persona1.saludar(); // Output: Hola, mi nombre es Juan y tengo 30 años.

    }

}

Descripción del Código en Java

1. Clase Persona:
   La clase Persona define dos atributos, nombre y edad, que son privados. Los atributos se inicializan a través de un constructor.

2. Constructor:
   El constructor de la clase Persona toma dos parámetros, nombre y edad, que se asignan a los atributos de la clase.

3. Método saludar:
   Este método imprime un mensaje en la consola utilizando el método System.out.println, similar a console.log en JavaScript.

4. Método main:
   El método main es el punto de entrada del programa. Aquí se crea una instancia de la clase Persona y se llama al método saludar para mostrar el mensaje en la consola.

Ejercicio

Ahora es tu turno. Crea una clase Coche con los siguientes requisitos:

• Atributos: marca, modelo, año.

• Método: detalles que imprime los detalles del coche en formato: "Este coche es un [marca] [modelo] del año [año]."

JavaScript. Aquí tienes un esquema para ayudarte a empezar:

// Definición de la clase Coche

class Coche {

  // Constructor

  constructor(marca, modelo, año) {

    this.marca = marca;

    this.modelo = modelo;

    this.año = año;

  }

  // Método detalles

  detalles() {

    console.log(`Este coche es un ${this.marca} ${this.modelo} del año ${this.año}.`);

  }

}

// Crear un objeto de la clase Coche

const coche1 = new Coche('Toyota', 'Corolla', 2020);

// Usar el método detalles

coche1.detalles(); // Output: Este coche es un Toyota Corolla del año 2020.

Java. Aquí tienes un esquema para ayudarte a empezar:

// Definición de la clase Coche

public class Coche {

    // Atributos de la clase

    private String marca;

    private String modelo;

    private int año;

    // Constructor de la clase

    public Coche(String marca, String modelo, int año) {

        this.marca = marca; // Asignación del atributo marca

        this.modelo = modelo; // Asignación del atributo modelo

        this.año = año; // Asignación del atributo año

    }

    // Método detalles

    public void detalles() {

        System.out.println("Este coche es un " + this.marca + " " + this.modelo + " del año " + this.año + ".");

    }

    // Método main para ejecutar el código

    public static void main(String[] args) {

        // Crear un objeto de la clase Coche

        Coche coche1 = new Coche("Toyota", "Corolla", 2020);

        // Usar el método detalles

        coche1.detalles(); // Output: Este coche es un Toyota Corolla del año 2020.

    }

}

Practica creando varios objetos Coche con diferentes marcas, modelos y años, y llama al método detalles para cada uno de ellos.

Concepto de Encapsulamiento

El encapsulamiento es uno de los pilares fundamentales de la Programación Orientada a Objetos. Consiste en restringir el acceso directo a ciertos componentes de un objeto y controlar cómo estos pueden ser modificados o accedidos. Esto se logra mediante la definición de atributos y métodos como privados o protegidos, permitiendo que solo los métodos dentro de la misma clase puedan acceder o modificar estos datos.

El encapsulamiento protege la integridad de los datos y asegura que los objetos se comporten de manera coherente y predecible, lo que facilita el mantenimiento y la evolución del código.

Beneficios del Encapsulamiento

• Protección de datos: Los atributos sensibles o críticos no pueden ser modificados directamente desde fuera de la clase, evitando comportamientos inesperados.

• Modularidad: Facilita la modularidad del código, ya que los cambios internos en la implementación de una clase no afectan a otras partes del programa.

• Mantenibilidad: Hace que el código sea más fácil de mantener, ya que puedes controlar y rastrear cómo se accede y modifica el estado de un objeto.

Encapsulamiento en JavaScript

En JavaScript, el encapsulamiento se puede implementar de varias maneras, incluyendo el uso de convenciones, propiedades privadas y métodos de acceso (getters y setters).

Ejemplo 1: Convención de Nombre

Una convención común en JavaScript es usar un guion bajo (_) al principio del nombre de un atributo para indicar que es privado.

javascript

class Persona {

    constructor(nombre, edad) {

        this._nombre = nombre; // Convención de nombre para indicar privado

        this._edad = edad;

    }

    // Método para acceder al nombre

    getNombre() {

        return this._nombre;

    }

    // Método para modificar la edad

    setEdad(nuevaEdad) {

        if (nuevaEdad > 0) {

            this._edad = nuevaEdad;

        } else {

            console.log('La edad debe ser un número positivo.');

        }

    }

    // Método para mostrar información de la persona

    mostrarInfo() {

        console.log(`Nombre: ${this._nombre}, Edad: ${this._edad}`);

    }

}

const persona1 = new Persona('Juan', 30);

persona1.mostrarInfo(); // Output: Nombre: Juan, Edad: 30

persona1.setEdad(35);

persona1.mostrarInfo(); // Output: Nombre: Juan, Edad: 35

persona1.setEdad(-5); // Output: La edad debe ser un número positivo.

Ejemplo 2: Propiedades Privadas con #

Desde ES6, JavaScript permite el uso de la sintaxis # para definir atributos privados que no pueden ser accedidos fuera de la clase.

javascript

class CuentaBancaria {

    #saldo; // Atributo privado

    constructor(titular, saldoInicial) {

        this.titular = titular;

        this.#saldo = saldoInicial; // Asignación inicial del saldo

    }

    // Método para depositar dinero

    depositar(cantidad) {

        if (cantidad > 0) {

            this.#saldo += cantidad;

            console.log(`Depositaste ${cantidad}. Nuevo saldo: ${this.#saldo}`);

        } else {

            console.log('La cantidad a depositar debe ser mayor que cero.');

        }

    }

    // Método para retirar dinero

    retirar(cantidad) {

        if (cantidad > 0 && cantidad <= this.#saldo) {

            this.#saldo -= cantidad;

            console.log(`Retiraste ${cantidad}. Nuevo saldo: ${this.#saldo}`);

        } else {

            console.log('Fondos insuficientes o cantidad inválida.');

        }

    }

    // Método para consultar el saldo

    consultarSaldo() {

        console.log(`El saldo de ${this.titular} es ${this.#saldo}`);

    }

}

const cuenta1 = new CuentaBancaria('Ana', 1000);

cuenta1.consultarSaldo(); // Output: El saldo de Ana es 1000

cuenta1.depositar(500);   // Output: Depositaste 500. Nuevo saldo: 1500

cuenta1.retirar(200);     // Output: Retiraste 200. Nuevo saldo: 1300

En este ejemplo, el saldo (#saldo) es un atributo privado que no puede ser accedido directamente desde fuera de la clase CuentaBancaria.

Métodos de Acceso: Getters y Setters

Para interactuar con atributos privados, se utilizan los métodos get y set, que permiten obtener y modificar el valor de los atributos de manera controlada.

javascript

class Producto {

    #precio; // Atributo privado

    constructor(nombre, precio) {

        this.nombre = nombre;

        this.#precio = precio;

    }

    // Getter para obtener el precio

    get precio() {

        return this.#precio;

    }

    // Setter para establecer un nuevo precio

    set precio(nuevoPrecio) {

        if (nuevoPrecio > 0) {

            this.#precio = nuevoPrecio;

        } else {

            console.log('El precio debe ser un número positivo.');

        }

    }

}

const producto1 = new Producto('Laptop', 1200);

console.log(producto1.precio); // Output: 1200

producto1.precio = 1500; // Actualiza el precio

console.log(producto1.precio); // Output: 1500

producto1.precio = -100; // Output: El precio debe ser un número positivo.

Aquí, usamos get para acceder al precio y set para modificarlo, asegurando que el valor siempre sea positivo.

Resumen y Tareas

Hoy hemos aprendido sobre el encapsulamiento, su importancia para proteger los datos y cómo implementarlo en JavaScript usando convenciones, atributos privados, y métodos de acceso (getters y setters).

Tareas para Practicar:

1. Crear una clase Vehiculo con atributos marca, modelo, y #kilometraje (privado).

class Vehiculo {

    // Atributo privado #kilometraje

    #kilometraje;

    // Constructor de la clase Vehiculo

    constructor(marca, modelo, kilometrajeInicial) {

        this.marca = marca;

        this.modelo = modelo;

        this.#kilometraje = kilometrajeInicial; // Asignación del kilometraje inicial

    }

    // Método getter para obtener el valor de #kilometraje

    getKilometraje() {

        return this.#kilometraje;

    }

    // Método setter para establecer un nuevo valor para #kilometraje

    setKilometraje(nuevoKilometraje) {

        if (nuevoKilometraje >= 0) {

            this.#kilometraje = nuevoKilometraje;

            console.log(`El kilometraje ha sido actualizado a ${this.#kilometraje} km.`);

        } else {

            console.log('El kilometraje debe ser un número positivo.');

        }

    }

    // Método para mostrar información del vehículo

    mostrarInfo() {

        console.log(`Marca: ${this.marca}, Modelo: ${this.modelo}, Kilometraje: ${this.#kilometraje} km.`);

    }

}

2. Implementar métodos getKilometraje y setKilometraje que permitan consultar y modificar el kilometraje, asegurando que el nuevo valor sea positivo.

// Crear un objeto de la clase Vehiculo

const vehiculo1 = new Vehiculo('Toyota', 'Corolla', 50000);

// Mostrar información inicial del vehículo

vehiculo1.mostrarInfo(); // Output: Marca: Toyota, Modelo: Corolla, Kilometraje: 50000 km.

// Consultar el kilometraje actual

console.log(`Kilometraje actual: ${vehiculo1.getKilometraje()} km`); // Output: Kilometraje actual: 50000 km

// Actualizar el kilometraje a un nuevo valor válido

vehiculo1.setKilometraje(55000); // Output: El kilometraje ha sido actualizado a 55000 km.

// Intentar actualizar el kilometraje a un valor negativo

vehiculo1.setKilometraje(-100); // Output: El kilometraje debe ser un número positivo.

// Mostrar la información del vehículo después de la actualización

vehiculo1.mostrarInfo(); // Output: Marca: Toyota, Modelo: Corolla, Kilometraje: 55000 km.

3. Crear objetos de la clase Vehiculo y probar los métodos implementados.

// Crear otro objeto de la clase Vehiculo

const vehiculo2 = new Vehiculo('Honda', 'Civic', 30000);

// Mostrar información inicial del segundo vehículo

vehiculo2.mostrarInfo(); // Output: Marca: Honda, Modelo: Civic, Kilometraje: 30000 km.

// Consultar el kilometraje actual del segundo vehículo

console.log(`Kilometraje actual: ${vehiculo2.getKilometraje()} km`); // Output: Kilometraje actual: 30000 km

// Actualizar el kilometraje a un nuevo valor válido

vehiculo2.setKilometraje(32000); // Output: El kilometraje ha sido actualizado a 32000 km.

// Mostrar la información del segundo vehículo después de la actualización

vehiculo2.mostrarInfo(); // Output: Marca: Honda, Modelo: Civic, Kilometraje: 32000 km.

¡Esto concluye nuestra sesión del Día 2 sobre Encapsulamiento! Mañana continuaremos con el tema de Herencia.

Concepto de Herencia

La herencia es un principio fundamental de la Programación Orientada a Objetos que permite crear nuevas clases a partir de clases existentes. Las clases derivadas (o "subclases") heredan atributos y métodos de una clase base (o "superclase"), lo que facilita la reutilización del código y la creación de jerarquías de clases más organizadas y lógicas.

La herencia permite que las subclases puedan extender o modificar el comportamiento de la clase base, lo que es útil para evitar duplicación de código y mantener un diseño más limpio y manejable.

Beneficios de la Herencia

• Reutilización de Código: Las subclases pueden reutilizar el código existente de la clase base, evitando la repetición de código.

• Extensibilidad: Permite agregar o modificar funcionalidades en subclases sin alterar la clase base.

• Organización Jerárquica: Facilita la creación de una estructura jerárquica donde las clases más específicas derivan de clases más generales.

Herencia en JavaScript

En JavaScript, la herencia se implementa utilizando la palabra clave extends para crear una subclase que hereda de una clase base. La palabra clave super se utiliza para llamar al constructor o a métodos de la clase base desde la subclase.

Ejemplo 1: Creación de una Jerarquía de Clases

Supongamos que estamos creando un sistema para gestionar vehículos, y queremos crear diferentes tipos de vehículos como automóviles y motocicletas. En lugar de repetir código, podemos crear una clase base Vehiculo y derivar de ella clases específicas como Automovil y Motocicleta.

javascript

// Clase base Vehiculo

class Vehiculo {

    constructor(marca, modelo, año) {

        this.marca = marca;

        this.modelo = modelo;

        this.año = año;

    }

    // Método para mostrar la información del vehículo

    mostrarInfo() {

        console.log(`Vehículo: ${this.marca} ${this.modelo} (${this.año})`);

    }

}

// Subclase Automovil que hereda de Vehiculo

class Automovil extends Vehiculo {

    constructor(marca, modelo, año, puertas) {

        super(marca, modelo, año); // Llamada al constructor de la clase base

        this.puertas = puertas;

    }

    // Método específico de Automovil

    mostrarInfo() {

        super.mostrarInfo(); // Llamada al método de la clase base

        console.log(`Puertas: ${this.puertas}`);

    }

}

// Subclase Motocicleta que hereda de Vehiculo

class Motocicleta extends Vehiculo {

    constructor(marca, modelo, año, tipo) {

        super(marca, modelo, año); // Llamada al constructor de la clase base

        this.tipo = tipo;

    }

    // Método específico de Motocicleta

    mostrarInfo() {

        super.mostrarInfo(); // Llamada al método de la clase base

        console.log(`Tipo: ${this.tipo}`);

    }

}

Ejemplo 2: Creación y Uso de Objetos de Subclases

Vamos a crear instancias de las clases Automovil y Motocicleta y utilizar sus métodos para ver cómo la herencia facilita la reutilización del código.

javascript

// Crear un objeto de la clase Automovil

const auto1 = new Automovil('Toyota', 'Corolla', 2021, 4);

auto1.mostrarInfo();

// Output: 

// Vehículo: Toyota Corolla (2021)

// Puertas: 4

// Crear un objeto de la clase Motocicleta

const moto1 = new Motocicleta('Honda', 'CBR', 2022, 'Deportiva');

moto1.mostrarInfo();

// Output: 

// Vehículo: Honda CBR (2022)

// Tipo: Deportiva

Explicación

• Clase Base Vehiculo: Define los atributos comunes a todos los vehículos (marca, modelo, año) y un método para mostrar esta información.

• Subclase Automovil: Hereda de Vehiculo y añade un atributo específico (puertas). Además, sobrescribe el método mostrarInfo() para incluir información adicional sobre el número de puertas.

• Subclase Motocicleta: También hereda de Vehiculo, pero añade un atributo diferente (tipo) y sobrescribe mostrarInfo() para mostrar el tipo de motocicleta.

• Uso de super: Se utiliza para llamar al constructor y métodos de la clase base dentro de las subclases, permitiendo que las subclases amplíen o modifiquen la funcionalidad de la clase base.

Jerarquía de Clases en Acción

Este ejemplo muestra cómo se pueden crear jerarquías de clases para representar diferentes tipos de vehículos, reutilizando código de la clase base Vehiculo y añadiendo comportamientos específicos en las subclases Automovil y Motocicleta.

Tareas para Practicar

1. Crear una subclase Camion que herede de Vehiculo y añada un atributo capacidadCarga. Sobrescribe el método mostrarInfo() para incluir la capacidad de carga.

// Clase base Vehiculo

class Vehiculo {

    constructor(marca, modelo, año) {

        this.marca = marca;

        this.modelo = modelo;

        this.año = año;

    }

    // Método para mostrar la información del vehículo

    mostrarInfo() {

        console.log(`Vehículo: ${this.marca} ${this.modelo} (${this.año})`);

    }

}

// Subclase Camion que hereda de Vehiculo

class Camion extends Vehiculo {

    constructor(marca, modelo, año, capacidadCarga) {

        super(marca, modelo, año); // Llamada al constructor de la clase base

        this.capacidadCarga = capacidadCarga;

    }

    // Sobrescribir el método mostrarInfo para incluir la capacidad de carga

    mostrarInfo() {

        super.mostrarInfo(); // Llamada al método de la clase base

        console.log(`Capacidad de carga: ${this.capacidadCarga} toneladas`);

    }

}

2. Crear varios objetos de Automovil, Motocicleta, y Camion, y utilizar sus métodos para mostrar la información completa de cada vehículo.

// Subclase Automovil que hereda de Vehiculo

class Automovil extends Vehiculo {

    constructor(marca, modelo, año, puertas) {

        super(marca, modelo, año);

        this.puertas = puertas;

    }

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Puertas: ${this.puertas}`);

    }

}

// Subclase Motocicleta que hereda de Vehiculo

class Motocicleta extends Vehiculo {

    constructor(marca, modelo, año, tipo) {

        super(marca, modelo, año);

        this.tipo = tipo;

    }

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Tipo: ${this.tipo}`);

    }

}

// Crear y mostrar información de un Automovil

const auto1 = new Automovil('Toyota', 'Corolla', 2021, 4);

auto1.mostrarInfo();

// Output: 

// Vehículo: Toyota Corolla (2021)

// Puertas: 4

// Crear y mostrar información de una Motocicleta

const moto1 = new Motocicleta('Honda', 'CBR', 2022, 'Deportiva');

moto1.mostrarInfo();

// Output: 

// Vehículo: Honda CBR (2022)

// Tipo: Deportiva

// Crear y mostrar información de un Camion

const camion1 = new Camion('Volvo', 'FH16', 2020, 18);

camion1.mostrarInfo();

// Output: 

// Vehículo: Volvo FH16 (2020)

// Capacidad de carga: 18 toneladas

3. Experimentar con la Sobrescritura de Métodos: Intenta modificar y extender otros métodos en las subclases para observar cómo funciona la herencia y la sobrescritura.

// Clase base Vehiculo con método arrancar

class Vehiculo {

    constructor(marca, modelo, año) {

        this.marca = marca;

        this.modelo = modelo;

        this.año = año;

    }

    mostrarInfo() {

        console.log(`Vehículo: ${this.marca} ${this.modelo} (${this.año})`);

    }

    // Método arrancar

    arrancar() {

        console.log(`El ${this.marca} ${this.modelo} está arrancando...`);

    }

}

// Subclase Automovil que hereda de Vehiculo y sobrescribe el método arrancar

class Automovil extends Vehiculo {

    constructor(marca, modelo, año, puertas) {

        super(marca, modelo, año);

        this.puertas = puertas;

    }

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Puertas: ${this.puertas}`);

    }

    arrancar() {

        console.log(`El automóvil ${this.marca} ${this.modelo} está arrancando en modo de conducción normal...`);

    }

}

// Subclase Motocicleta que hereda de Vehiculo y sobrescribe el método arrancar

class Motocicleta extends Vehiculo {

    constructor(marca, modelo, año, tipo) {

        super(marca, modelo, año);

        this.tipo = tipo;

    }

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Tipo: ${this.tipo}`);

    }

    arrancar() {

        console.log(`La motocicleta ${this.marca} ${this.modelo} está arrancando con un rugido potente...`);

    }

}

// Subclase Camion que hereda de Vehiculo y sobrescribe el método arrancar

class Camion extends Vehiculo {

    constructor(marca, modelo, año, capacidadCarga) {

        super(marca, modelo, año);

        this.capacidadCarga = capacidadCarga;

    }

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Capacidad de carga: ${this.capacidadCarga} toneladas`);

    }

    arrancar() {

        console.log(`El camión ${this.marca} ${this.modelo} está arrancando con un motor potente, listo para la carga...`);

    }

}

// Crear objetos y probar el método arrancar

const auto1 = new Automovil('Toyota', 'Corolla', 2021, 4);

auto1.arrancar(); // Output: El automóvil Toyota Corolla está arrancando en modo de conducción normal...

const moto1 = new Motocicleta('Honda', 'CBR', 2022, 'Deportiva');

moto1.arrancar(); // Output: La motocicleta Honda CBR está arrancando con un rugido potente...

const camion1 = new Camion('Volvo', 'FH16', 2020, 18);

camion1.arrancar(); // Output: El camión Volvo FH16 está arrancando con un motor potente, listo para la carga...

Concepto de Polimorfismo

El polimorfismo es un concepto fundamental en la programación orientada a objetos que permite que las clases tengan diferentes implementaciones de un método bajo la misma interfaz o estructura. La palabra "polimorfismo" proviene del griego y significa "muchas formas", lo que implica que el mismo método puede actuar de manera diferente según el objeto que lo utilice. Esto es crucial para la flexibilidad y extensibilidad de un sistema, ya que permite tratar objetos de diferentes clases de manera uniforme.

Tipos de Polimorfismo

1. Polimorfismo en tiempo de compilación (estático): Este tipo de polimorfismo se logra mediante la sobrecarga de métodos y operadores. Los métodos sobrecargados comparten el mismo nombre pero tienen diferentes firmas (tipo o número de parámetros).

2. Polimorfismo en tiempo de ejecución (dinámico): Este tipo de polimorfismo se logra mediante la sobrescritura de métodos. Las clases derivadas pueden tener sus propias implementaciones de un método definido en la clase base.

Ejemplo en JavaScript

Supongamos que estamos creando una aplicación para gestionar diferentes tipos de cuentas de usuario (Usuario regular, Usuario Premium y Usuario Administrador). Utilizaremos el polimorfismo para definir diferentes comportamientos para cada tipo de usuario al enviar una notificación.

javascript

// Definición de la clase base Usuario

class Usuario {

    constructor(nombre) {

        this.nombre = nombre;

    }

    enviarNotificacion(mensaje) {

        console.log(`${this.nombre} recibió una notificación: ${mensaje}`);

    }

}

// Clase derivada UsuarioRegular

class UsuarioRegular extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Regular) ${this.nombre} recibió un correo electrónico: ${mensaje}`);

    }

}

// Clase derivada UsuarioPremium

class UsuarioPremium extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Premium) ${this.nombre} recibió una notificación por SMS: ${mensaje}`);

    }

}

// Clase derivada UsuarioAdministrador

class UsuarioAdministrador extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Admin) ${this.nombre} recibió una alerta en la aplicación: ${mensaje}`);

    }

}

// Crear objetos de cada clase de usuario

const usuario1 = new UsuarioRegular('Ana');

const usuario2 = new UsuarioPremium('Carlos');

const usuario3 = new UsuarioAdministrador('Elena');

// Enviar notificaciones

usuario1.enviarNotificacion('Tu pedido ha sido enviado.');

// Output: (Regular) Ana recibió un correo electrónico: Tu pedido ha sido enviado.

usuario2.enviarNotificacion('Tu pedido ha sido entregado.');

// Output: (Premium) Carlos recibió una notificación por SMS: Tu pedido ha sido entregado.

usuario3.enviarNotificacion('Hay una nueva actualización disponible.');

// Output: (Admin) Elena recibió una alerta en la aplicación: Hay una nueva actualización disponible.

En este ejemplo:

• Definimos una clase base Usuario con un método enviarNotificacion que se encarga de enviar una notificación al usuario.

• Creamos clases derivadas UsuarioRegular, UsuarioPremium y UsuarioAdministrador, cada una con su propia implementación del método enviarNotificacion.

• El método enviarNotificacion está sobrescrito en cada clase derivada para proporcionar un comportamiento específico según el tipo de usuario.

• Creamos objetos de cada tipo de usuario y utilizamos el método enviarNotificacion para demostrar cómo cada usuario recibe la notificación de manera diferente.

Ejercicio

Ahora es tu turno. Crea una clase Figura para una aplicación de dibujo con los siguientes requisitos:

• Atributos: nombre.

• Métodos:

  • calcularArea(): Método abstracto que será sobrescrito por las clases derivadas.

  • dibujar(): Método abstracto que será sobrescrito por las clases derivadas.

Crea clases derivadas Circulo, Rectangulo, y Triangulo, cada una con su propia implementación de calcularArea() y dibujar().

Esquema

javascript

// Definición de la clase base Figura

class Figura {

    constructor(nombre) {

        this.nombre = nombre;

    }

    calcularArea() {

        throw new Error("Este método debe ser implementado por una clase derivada.");

    }

    dibujar() {

        throw new Error("Este método debe ser implementado por una clase derivada.");

    }

}

// Clase derivada Circulo

class Circulo extends Figura {

    constructor(nombre, radio) {

        super(nombre);

        this.radio = radio;

    }

    calcularArea() {

        return Math.PI * this.radio ** 2;

    }

    dibujar() {

        console.log(`Dibujando un círculo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Clase derivada Rectangulo

class Rectangulo extends Figura {

    constructor(nombre, ancho, alto) {

        super(nombre);

        this.ancho = ancho;

        this.alto = alto;

    }

    calcularArea() {

        return this.ancho * this.alto;

    }

    dibujar() {

        console.log(`Dibujando un rectángulo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Clase derivada Triangulo

class Triangulo extends Figura {

    constructor(nombre, base, altura) {

        super(nombre);

        this.base = base;

        this.altura = altura;

    }

    calcularArea() {

        return (this.base * this.altura) / 2;

    }

    dibujar() {

        console.log(`Dibujando un triángulo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Crear objetos de cada clase de figura

const circulo1 = new Circulo('Círculo1', 5);

const rectangulo1 = new Rectangulo('Rectángulo1', 4, 6);

const triangulo1 = new Triangulo('Triángulo1', 3, 4);

// Usar los métodos calcularArea y dibujar

circulo1.dibujar();     // Output: Dibujando un círculo llamado Círculo1 con área 78.53981633974483

rectangulo1.dibujar();  // Output: Dibujando un rectángulo llamado Rectángulo1 con área 24

triangulo1.dibujar();   // Output: Dibujando un triángulo llamado Triángulo1 con área 6

En este ejemplo:

• Definimos la clase base Figura con métodos abstractos calcularArea() y dibujar().

• Creamos clases derivadas Circulo, Rectangulo, y Triangulo, cada una implementando su propia lógica para los métodos.

• Implementamos y usamos los métodos calcularArea() y dibujar() para cada tipo de figura, demostrando la capacidad del polimorfismo para manejar diferentes objetos de manera uniforme.

Concepto de Polimorfismo

El polimorfismo es un concepto fundamental en la programación orientada a objetos que permite que las clases tengan diferentes implementaciones de un método bajo la misma interfaz o estructura. La palabra "polimorfismo" proviene del griego y significa "muchas formas", lo que implica que el mismo método puede actuar de manera diferente según el objeto que lo utilice. Esto es crucial para la flexibilidad y extensibilidad de un sistema, ya que permite tratar objetos de diferentes clases de manera uniforme.

Tipos de Polimorfismo

1. Polimorfismo en tiempo de compilación (estático): Este tipo de polimorfismo se logra mediante la sobrecarga de métodos y operadores. Los métodos sobrecargados comparten el mismo nombre pero tienen diferentes firmas (tipo o número de parámetros).

2. Polimorfismo en tiempo de ejecución (dinámico): Este tipo de polimorfismo se logra mediante la sobrescritura de métodos. Las clases derivadas pueden tener sus propias implementaciones de un método definido en la clase base.

Ejemplo en JavaScript

Supongamos que estamos creando una aplicación para gestionar diferentes tipos de cuentas de usuario (Usuario regular, Usuario Premium y Usuario Administrador). Utilizaremos el polimorfismo para definir diferentes comportamientos para cada tipo de usuario al enviar una notificación.

javascript

// Definición de la clase base Usuario

class Usuario {

    constructor(nombre) {

        this.nombre = nombre;

    }

    enviarNotificacion(mensaje) {

        console.log(`${this.nombre} recibió una notificación: ${mensaje}`);

    }

}

// Clase derivada UsuarioRegular

class UsuarioRegular extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Regular) ${this.nombre} recibió un correo electrónico: ${mensaje}`);

    }

}

// Clase derivada UsuarioPremium

class UsuarioPremium extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Premium) ${this.nombre} recibió una notificación por SMS: ${mensaje}`);

    }

}

// Clase derivada UsuarioAdministrador

class UsuarioAdministrador extends Usuario {

    enviarNotificacion(mensaje) {

        console.log(`(Admin) ${this.nombre} recibió una alerta en la aplicación: ${mensaje}`);

    }

}

// Crear objetos de cada clase de usuario

const usuario1 = new UsuarioRegular('Ana');

const usuario2 = new UsuarioPremium('Carlos');

const usuario3 = new UsuarioAdministrador('Elena');

// Enviar notificaciones

usuario1.enviarNotificacion('Tu pedido ha sido enviado.');

// Output: (Regular) Ana recibió un correo electrónico: Tu pedido ha sido enviado.

usuario2.enviarNotificacion('Tu pedido ha sido entregado.');

// Output: (Premium) Carlos recibió una notificación por SMS: Tu pedido ha sido entregado.

usuario3.enviarNotificacion('Hay una nueva actualización disponible.');

// Output: (Admin) Elena recibió una alerta en la aplicación: Hay una nueva actualización disponible.

En este ejemplo:

• Definimos una clase base Usuario con un método enviarNotificacion que se encarga de enviar una notificación al usuario.

• Creamos clases derivadas UsuarioRegular, UsuarioPremium y UsuarioAdministrador, cada una con su propia implementación del método enviarNotificacion.

• El método enviarNotificacion está sobrescrito en cada clase derivada para proporcionar un comportamiento específico según el tipo de usuario.

• Creamos objetos de cada tipo de usuario y utilizamos el método enviarNotificacion para demostrar cómo cada usuario recibe la notificación de manera diferente.

Ejercicio

Ahora es tu turno. Crea una clase Figura para una aplicación de dibujo con los siguientes requisitos:

• Atributos: nombre.

• Métodos:

  • calcularArea(): Método abstracto que será sobrescrito por las clases derivadas.

  • dibujar(): Método abstracto que será sobrescrito por las clases derivadas.

Crea clases derivadas Circulo, Rectangulo, y Triangulo, cada una con su propia implementación de calcularArea() y dibujar().

Esquema

javascript

// Definición de la clase base Figura

class Figura {

    constructor(nombre) {

        this.nombre = nombre;

    }

    calcularArea() {

        throw new Error("Este método debe ser implementado por una clase derivada.");

    }

    dibujar() {

        throw new Error("Este método debe ser implementado por una clase derivada.");

    }

}

// Clase derivada Circulo

class Circulo extends Figura {

    constructor(nombre, radio) {

        super(nombre);

        this.radio = radio;

    }

    calcularArea() {

        return Math.PI * this.radio ** 2;

    }

    dibujar() {

        console.log(`Dibujando un círculo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Clase derivada Rectangulo

class Rectangulo extends Figura {

    constructor(nombre, ancho, alto) {

        super(nombre);

        this.ancho = ancho;

        this.alto = alto;

    }

    calcularArea() {

        return this.ancho * this.alto;

    }

    dibujar() {

        console.log(`Dibujando un rectángulo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Clase derivada Triangulo

class Triangulo extends Figura {

    constructor(nombre, base, altura) {

        super(nombre);

        this.base = base;

        this.altura = altura;

    }

    calcularArea() {

        return (this.base * this.altura) / 2;

    }

    dibujar() {

        console.log(`Dibujando un triángulo llamado ${this.nombre} con área ${this.calcularArea()}`);

    }

}

// Crear objetos de cada clase de figura

const circulo1 = new Circulo('Círculo1', 5);

const rectangulo1 = new Rectangulo('Rectángulo1', 4, 6);

const triangulo1 = new Triangulo('Triángulo1', 3, 4);

// Usar los métodos calcularArea y dibujar

circulo1.dibujar();     // Output: Dibujando un círculo llamado Círculo1 con área 78.53981633974483

rectangulo1.dibujar();  // Output: Dibujando un rectángulo llamado Rectángulo1 con área 24

triangulo1.dibujar();   // Output: Dibujando un triángulo llamado Triángulo1 con área 6

En este ejemplo:

• Definimos la clase base Figura con métodos abstractos calcularArea() y dibujar().

• Creamos clases derivadas Circulo, Rectangulo, y Triangulo, cada una implementando su propia lógica para los métodos.

• Implementamos y usamos los métodos calcularArea() y dibujar() para cada tipo de figura, demostrando la capacidad del polimorfismo para manejar diferentes objetos de manera uniforme.

Hoy nos enfocaremos en crear y practicar con clases simples, atributos y métodos en JavaScript. Estos ejercicios te ayudarán a solidificar tu comprensión de los conceptos básicos de POO.

Ejercicio 1: Clase Animal

Crea una clase Animal con los siguientes requisitos:

• Atributos: nombre, especie, edad.

• Métodos:

  • comer: Muestra un mensaje indicando que el animal está comiendo.

  • dormir: Muestra un mensaje indicando que el animal está durmiendo.

  • hacerSonido: Muestra un mensaje indicando el sonido que hace el animal.

class Animal {

  constructor(nombre, especie, edad) {

    this.nombre = nombre;

    this.especie = especie;

    this.edad = edad;

  }

  comer() {

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

  }

  dormir() {

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

  }

  hacerSonido() {

    console.log(`${this.nombre} hace un sonido.`);

  }

}

// Crear un objeto de la clase Animal

const animal1 = new Animal('Luna', 'Gato', 3);

// Usar los métodos

animal1.comer();       // Output: Luna está comiendo.

animal1.dormir();      // Output: Luna está durmiendo.

animal1.hacerSonido(); // Output: Luna hace un sonido.

Ejercicio 2: Clase Estudiante

Crea una clase Estudiante con los siguientes requisitos:

• Atributos: nombre, matricula, carrera.

• Métodos:

  • estudiar: Muestra un mensaje indicando que el estudiante está estudiando.

  • presentarExamen: Muestra un mensaje indicando que el estudiante está presentando un examen.

  • mostrarInformacion: Muestra la información del estudiante.

class Estudiante {

  constructor(nombre, matricula, carrera) {

    this.nombre = nombre;

    this.matricula = matricula;

    this.carrera = carrera;

  }

  estudiar() {

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

  }

  presentarExamen() {

    console.log(`${this.nombre} está presentando un examen.`);

  }

  mostrarInformacion() {

    console.log(`Nombre: ${this.nombre}, Matrícula: ${this.matricula}, Carrera: ${this.carrera}`);

  }

}

// Crear un objeto de la clase Estudiante

const estudiante1 = new Estudiante('Carlos', '123456', 'Ingeniería');

// Usar los métodos

estudiante1.estudiar();          // Output: Carlos está estudiando.

estudiante1.presentarExamen();   // Output: Carlos está presentando un examen.

estudiante1.mostrarInformacion(); // Output: Nombre: Carlos, Matrícula: 123456, Carrera: Ingeniería.

Ejercicio 3: Clase Libro

Crea una clase Libro con los siguientes requisitos:

• Atributos: titulo, autor, paginas.

• Métodos:

  • leerPagina: Muestra un mensaje indicando que estás leyendo una página del libro.

  • mostrarInformacion: Muestra la información del libro.

  • terminarLibro: Muestra un mensaje indicando que has terminado de leer el libro.

class Libro {

  constructor(titulo, autor, paginas) {

    this.titulo = titulo;

    this.autor = autor;

    this.paginas = paginas;

  }

  leerPagina() {

    console.log(`Estás leyendo una página de "${this.titulo}".`);

  }

  mostrarInformacion() {

    console.log(`Título: ${this.titulo}, Autor: ${this.autor}, Páginas: ${this.paginas}`);

  }

  terminarLibro() {

    console.log(`Has terminado de leer "${this.titulo}".`);

  }

}

// Crear un objeto de la clase Libro

const libro1 = new Libro('1984', 'George Orwell', 328);

// Usar los métodos

libro1.leerPagina();          // Output: Estás leyendo una página de "1984".

libro1.mostrarInformacion();  // Output: Título: 1984, Autor: George Orwell, Páginas: 328.

libro1.terminarLibro();       // Output: Has terminado de leer "1984".

Ejercicio 4: Clase Coche

Crea una clase Coche con los siguientes requisitos:

• Atributos: marca, modelo, año.

• Métodos:

  • arrancar: Muestra un mensaje indicando que el coche ha arrancado.

  • detener: Muestra un mensaje indicando que el coche se ha detenido.

  • mostrarInformacion: Muestra la información del coche.

class Coche {

  constructor(marca, modelo, año) {

    this.marca = marca;

    this.modelo = modelo;

    this.año = año;

  }

  arrancar() {

    console.log(`El coche ${this.marca} ${this.modelo} ha arrancado.`);

  }

  detener() {

    console.log(`El coche ${this.marca} ${this.modelo} se ha detenido.`);

  }

  mostrarInformacion() {

    console.log(`Marca: ${this.marca}, Modelo: ${this.modelo}, Año: ${this.año}`);

  }

}

// Crear un objeto de la clase Coche

const coche1 = new Coche('Toyota', 'Corolla', 2020);

// Usar los métodos

coche1.arrancar();          // Output: El coche Toyota Corolla ha arrancado.

coche1.detener();           // Output: El coche Toyota Corolla se ha detenido.

coche1.mostrarInformacion(); // Output: Marca: Toyota, Modelo: Corolla, Año: 2020.

Ejercicio 5: Clase Persona

Crea una clase Persona con los siguientes requisitos:

• Atributos: nombre, edad, genero.

• Métodos:

  • presentarse: Muestra un mensaje presentándose a sí mismo.

  • cumplirAños: Incrementa la edad en 1 y muestra un mensaje de cumpleaños.

  • mostrarInformacion: Muestra la información de la persona.

javascript

Copiar código

 class Persona {

  constructor(nombre, edad, genero) {

    this.nombre = nombre;

    this.edad = edad;

    this.genero = genero;

  }

  presentarse() {

    console.log(`Hola, me llamo ${this.nombre}.`);

  }

  cumplirAños() {

    this.edad += 1;

    console.log(`¡Feliz cumpleaños, ${this.nombre}! Ahora tienes ${this.edad} años.`);

  }

  mostrarInformacion() {

    console.log(`Nombre: ${this.nombre}, Edad: ${this.edad}, Género: ${this.genero}`);

  }

}

// Crear un objeto de la clase Persona

const persona1 = new Persona('Ana', 25, 'Femenino');

// Usar los métodos

persona1.presentarse();       // Output: Hola, me llamo Ana.

persona1.cumplirAños();       // Output: ¡Feliz cumpleaños, Ana! Ahora tienes 26 años.

persona1.mostrarInformacion(); // Output: Nombre: Ana, Edad: 26, Género: Femenino.

Estos ejercicios prácticos te ayudarán a reforzar los conceptos de clases, atributos y métodos en JavaScript. Practica creando más clases y objetos según tus intereses y necesidades para mejorar tus habilidades en POO. ¡Buena suerte!

Repaso de Conceptos

Antes de hacer el cuestionario, repasemos los conceptos clave que hemos cubierto hasta ahora:

1. Clases y Objetos:

   • Clase: Plantilla o modelo que define propiedades y métodos.

   • Objeto: Instancia de una clase.

2. Atributos y Métodos:

   • Atributos: Propiedades de un objeto.

   • Métodos: Funciones asociadas a un objeto.

3. Encapsulamiento:

   • Ocultar los detalles internos y exponer solo lo necesario.

4. Abstracción:

   • Simplificar la complejidad mostrando solo los detalles esenciales.

5. Herencia:

   • Permite que una clase herede propiedades y métodos de otra.

6. Polimorfismo:

   • Permite que una misma operación se ejecute de diferentes maneras en distintas clases.

Cuestionario

1. Pregunta 1: ¿Qué es una clase en POO?

   • a) Un tipo de dato que contiene un solo valor.

   • b) Una plantilla para crear objetos.

   • c) Una función que se ejecuta automáticamente.

   • d) Un método para ocultar información.

2. Pregunta 2: ¿Qué es un objeto en POO?

   • a) Una instancia de una clase.

   • b) Un conjunto de funciones.

   • c) Una variable global.

   • d) Una operación matemática.

3. Pregunta 3: ¿Qué es el encapsulamiento?

   • a) Proceso de heredar propiedades de una clase.

   • b) Técnica para ocultar los detalles internos y exponer solo lo necesario.

   • c) Crear múltiples instancias de una clase.

   • d) Definir múltiples métodos con el mismo nombre.

4. Pregunta 4: ¿Qué es la abstracción?

   • a) La capacidad de un objeto para tomar muchas formas.

   • b) La acción de definir clases y objetos.

   • c) Simplificar la complejidad mostrando solo los detalles esenciales.

   • d) Compartir métodos y propiedades entre clases.

5. Pregunta 5: ¿Cuál es la diferencia entre atributos y métodos?

   • a) Los atributos son funciones y los métodos son variables.

   • b) Los atributos son propiedades de un objeto y los métodos son funciones asociadas al objeto.

   • c) Los atributos son públicos y los métodos son privados.

   • d) No hay diferencia, son lo mismo.

6. Pregunta 6: ¿Qué es la herencia en POO?

   • a) La capacidad de definir una función dentro de una clase.

   • b) La técnica de ocultar los detalles internos de un objeto.

   • c) El mecanismo por el cual una clase puede heredar propiedades y métodos de otra clase.

   • d) La habilidad de un objeto para interactuar con otros objetos.

7. Pregunta 7: ¿Qué es el polimorfismo?

   • a) La capacidad de un objeto para cambiar su estado interno.

   • b) La capacidad de un objeto para tomar muchas formas.

   • c) La capacidad de una clase para heredar propiedades de otra clase.

   • d) La técnica de definir atributos y métodos.

Respuestas del Cuestionario

1. b) Una plantilla para crear objetos.

2. a) Una instancia de una clase.

3. b) Técnica para ocultar los detalles internos y exponer solo lo necesario.

4. c) Simplificar la complejidad mostrando solo los detalles esenciales.

5. b) Los atributos son propiedades de un objeto y los métodos son funciones asociadas al objeto.

6. c) El mecanismo por el cual una clase puede heredar propiedades y métodos de otra clase.

7. b) La capacidad de un objeto para tomar muchas formas.

Ejercicios Prácticos Adicionales

1. Ejercicio 1: Crear una clase Empleado con los siguientes atributos y métodos:

   • Atributos: nombre, puesto, salario.

   • Métodos: trabajar (muestra un mensaje indicando que el empleado está trabajando), recibirSalario (muestra un mensaje indicando que el empleado ha recibido su salario), mostrarInformacion (muestra la información del empleado).

2. Ejercicio 2: Crear una clase Producto con los siguientes atributos y métodos:

   • Atributos: nombre, precio, cantidad.

   • Métodos: comprar (reduce la cantidad en 1 y muestra un mensaje), reponer (incrementa la cantidad en un valor dado y muestra un mensaje), mostrarInformacion (muestra la información del producto).

Estos ejercicios adicionales te ayudarán a consolidar tu comprensión de los conceptos de POO. ¡Sigue practicando y buena suerte con tus estudios!

Concepto de Herencia Avanzada

La herencia avanzada amplía los conceptos básicos de herencia en POO para abordar relaciones más complejas entre clases y la sobrecarga de métodos. Estas técnicas permiten la creación de jerarquías de clases más ricas y la personalización del comportamiento de métodos en subclases, proporcionando flexibilidad y potencia en el diseño del software.

Relaciones Complejas en Herencia

En herencia avanzada, las relaciones entre clases pueden volverse más complejas, como en el caso de la herencia múltiple (aunque JavaScript no la soporta directamente), la herencia en profundidad (donde las subclases derivan de otras subclases), y las relaciones de composición junto con la herencia.

• Herencia en Profundidad: Implica la creación de una cadena de herencia donde una subclase hereda de otra subclase, formando una jerarquía de clases.

• Composición vs. Herencia: A veces, es mejor usar composición (donde un objeto contiene otros objetos) en lugar de herencia para evitar problemas como la rigidez de la jerarquía de clases o el "problema del diamante" en lenguajes con herencia múltiple.

Sobrecarga de Métodos

La sobrecarga de métodos ocurre cuando una clase tiene varios métodos con el mismo nombre, pero diferentes parámetros (tipo o número). Aunque JavaScript no soporta la sobrecarga de métodos de manera nativa como otros lenguajes (por ejemplo, Java o C++), se puede simular mediante patrones de diseño, utilizando la flexibilidad de los argumentos en JavaScript.

Ejemplo de Herencia Avanzada y Sobrecarga de Métodos

Vamos a crear un sistema de gestión de empleados en una empresa, con una jerarquía de clases que incluye empleados, gerentes, y directores, demostrando la herencia en profundidad y la sobrecarga de métodos.

Paso 1: Definir la Clase Base Empleado

javascript

// Clase base Empleado

class Empleado {

    constructor(nombre, salario) {

        this.nombre = nombre;

        this.salario = salario;

    }

    // Método para calcular el bono anual

    calcularBono(bono = 0.1) {

        return this.salario * bono;

    }

    // Método para mostrar la información del empleado

    mostrarInfo() {

        console.log(`Empleado: ${this.nombre}, Salario: ${this.salario}`);

    }

}

Paso 2: Crear una Subclase Gerente que Herede de Empleado

javascript

// Subclase Gerente que hereda de Empleado

class Gerente extends Empleado {

    constructor(nombre, salario, departamento) {

        super(nombre, salario);

        this.departamento = departamento;

    }

    // Sobrescribir el método mostrarInfo para incluir el departamento

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Departamento: ${this.departamento}`);

    }

    // Sobrecarga del método calcularBono

    calcularBono(bono = 0.15, bonoExtra = 0) {

        return super.calcularBono(bono) + bonoExtra;

    }

}

Paso 3: Crear una Subclase Director que Herede de Gerente

javascript

// Subclase Director que hereda de Gerente

class Director extends Gerente {

    constructor(nombre, salario, departamento, presupuesto) {

        super(nombre, salario, departamento);

        this.presupuesto = presupuesto;

    }

    // Sobrescribir el método mostrarInfo para incluir el presupuesto

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Presupuesto: ${this.presupuesto}`);

    }

    // Sobrecarga del método calcularBono con un bono adicional para directores

    calcularBono(bono = 0.2, bonoExtra = 5000) {

        return super.calcularBono(bono, bonoExtra) + this.presupuesto * 0.01;

    }

}

Paso 4: Crear y Probar Objetos de las Clases Empleado, Gerente, y Director

javascript

// Crear un objeto de la clase Empleado

const empleado1 = new Empleado('Juan', 30000);

empleado1.mostrarInfo(); // Output: Empleado: Juan, Salario: 30000

console.log(`Bono: ${empleado1.calcularBono()}`); // Output: Bono: 3000

// Crear un objeto de la clase Gerente

const gerente1 = new Gerente('Ana', 50000, 'Ventas');

gerente1.mostrarInfo();

// Output:

// Empleado: Ana, Salario: 50000

// Departamento: Ventas

console.log(`Bono: ${gerente1.calcularBono()}`); // Output: Bono: 7500

// Crear un objeto de la clase Director

const director1 = new Director('Carlos', 80000, 'Marketing', 200000);

director1.mostrarInfo();

// Output:

// Empleado: Carlos, Salario: 80000

// Departamento: Marketing

// Presupuesto: 200000

console.log(`Bono: ${director1.calcularBono()}`); // Output: Bono: 20500

Explicación

• Herencia en Profundidad: Gerente hereda de Empleado, y Director hereda de Gerente, formando una cadena de herencia que muestra cómo cada clase añade y personaliza la funcionalidad.

• Sobrecarga de Métodos: La clase Gerente y Director sobrecargan el método calcularBono para ofrecer diferentes cálculos basados en los parámetros adicionales, demostrando cómo se puede adaptar la funcionalidad heredada a las necesidades específicas de las subclases.

• Uso de super: Utilizamos super para llamar a métodos de la clase base, extendiendo su comportamiento en las subclases.

Relaciones Complejas y Composición

A veces, es más adecuado usar composición en lugar de herencia para evitar la creación de jerarquías rígidas y para facilitar la reutilización de código.

Ejemplo de Composición en Lugar de Herencia

javascript

// Clase Departamento

class Departamento {

    constructor(nombre) {

        this.nombre = nombre;

    }

    mostrarInfo() {

        console.log(`Departamento: ${this.nombre}`);

    }

}

// Clase Empleado que utiliza Composición en lugar de Herencia

class EmpleadoConDepartamento {

    constructor(nombre, salario, departamento) {

        this.nombre = nombre;

        this.salario = salario;

        this.departamento = new Departamento(departamento);

    }

    mostrarInfo() {

        console.log(`Empleado: ${this.nombre}, Salario: ${this.salario}`);

        this.departamento.mostrarInfo();

    }

}

// Crear un objeto de la clase EmpleadoConDepartamento

const empleadoConDepto = new EmpleadoConDepartamento('María', 40000, 'Recursos Humanos');

empleadoConDepto.mostrarInfo();

// Output:

// Empleado: María, Salario: 40000

// Departamento: Recursos Humanos

Notas

La herencia avanzada en POO permite crear sistemas más complejos y flexibles al aprovechar relaciones profundas entre clases y la sobrecarga de métodos. Sin embargo, también es importante considerar cuándo usar composición para evitar problemas comunes en jerarquías de herencia.

Tareas para Practicar

1. Crear una subclase JefeEquipo que herede de Gerente y añada un atributo equipo (array de nombres). Sobrescribe el método mostrarInfo para mostrar los nombres de los miembros del equipo.

// Subclase Gerente que hereda de Empleado

class Gerente extends Empleado {

    constructor(nombre, salario, departamento) {

        super(nombre, salario);

        this.departamento = departamento;

    }

    // Sobrescribir el método mostrarInfo para incluir el departamento

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Departamento: ${this.departamento}`);

    }

    // Sobrecarga del método calcularBono

    calcularBono(bono = 0.15, bonoExtra = 0) {

        return super.calcularBono(bono) + bonoExtra;

    }

}

// Subclase JefeEquipo que hereda de Gerente

class JefeEquipo extends Gerente {

    constructor(nombre, salario, departamento, equipo = []) {

        super(nombre, salario, departamento);

        this.equipo = equipo; // Array de nombres de los miembros del equipo

    }

    // Sobrescribir el método mostrarInfo para incluir los nombres del equipo

    mostrarInfo() {

        super.mostrarInfo();

        console.log(`Equipo: ${this.equipo.join(', ')}`);

    }

    // Sobrecarga del método calcularBono para incluir un bono basado en el tamaño del equipo

    calcularBono(bono = 0.15, bonoExtra = 1000) {

        const bonoPorMiembro = 500 * this.equipo.length; // Bono adicional por miembro del equipo

        return super.calcularBono(bono, bonoExtra) + bonoPorMiembro;

    }

}

// Crear un objeto de la clase JefeEquipo

const jefeEquipo1 = new JefeEquipo('Laura', 60000, 'Desarrollo', ['Carlos', 'Ana', 'Pedro']);

// Mostrar información del JefeEquipo

jefeEquipo1.mostrarInfo();

// Output:

// Empleado: Laura, Salario: 60000

// Departamento: Desarrollo

// Equipo: Carlos, Ana, Pedro

// Calcular y mostrar el bono del JefeEquipo

console.log(`Bono: ${jefeEquipo1.calcularBono()}`); 

// Output: Bono: 13000 (7500 + 1000 + 1500 por cada miembro)

2. Experimentar con la Sobrecarga de Métodos en JefeEquipo para calcular el bono basado en la cantidad de miembros del equipo.

// Clase Cliente

class Cliente {

    constructor(nombre, industria) {

        this.nombre = nombre;

        this.industria = industria;

    }

    mostrarInfo() {

        console.log(`Cliente: ${this.nombre}, Industria: ${this.industria}`);

    }

}

// Clase Empleado

class Empleado {

    constructor(nombre, rol) {

        this.nombre = nombre;

        this.rol = rol;

    }

    mostrarInfo() {

        console.log(`Empleado: ${this.nombre}, Rol: ${this.rol}`);

    }

}

// Clase Proyecto que usa Composición

class Proyecto {

    constructor(nombre, cliente, empleados = []) {

        this.nombre = nombre;

        this.cliente = cliente; // Composición: Proyecto tiene un Cliente

        this.empleados = empleados; // Composición: Proyecto tiene varios Empleados

    }

    // Método para agregar un empleado al proyecto

    agregarEmpleado(empleado) {

        this.empleados.push(empleado);

    }

    // Método para mostrar la información del proyecto

    mostrarInfo() {

        console.log(`Proyecto: ${this.nombre}`);

        this.cliente.mostrarInfo();

        console.log('Empleados en el proyecto:');

        this.empleados.forEach(empleado => empleado.mostrarInfo());

    }

}

//Crear y Probar un Objeto de la Clase Proyecto

javascript

// Crear un objeto de la clase Cliente

const cliente1 = new Cliente('Empresa ABC', 'Tecnología');

// Crear objetos de la clase Empleado

const empleado1 = new Empleado('Juan', 'Desarrollador');

const empleado2 = new Empleado('Sara', 'Diseñadora');

const empleado3 = new Empleado('Luis', 'Analista');

// Crear un objeto de la clase Proyecto

const proyecto1 = new Proyecto('Sistema de Gestión', cliente1, [empleado1, empleado2]);

// Agregar un nuevo empleado al proyecto

proyecto1.agregarEmpleado(empleado3);

// Mostrar información del Proyecto

proyecto1.mostrarInfo();

// Output:

// Proyecto: Sistema de Gestión

// Cliente: Empresa ABC, Industria: Tecnología

// Empleados en el proyecto:

// Empleado: Juan, Rol: Desarrollador

// Empleado: Sara, Rol: Diseñadora

// Empleado: Luis, Rol: Analista

3. Implementar un ejemplo de Composición donde un Proyecto tiene un Cliente y varios Empleados asociados. Define clases y métodos apropiados para gestionar esta relación.

Concepto de Polimorfismo Avanzado

El polimorfismo avanzado en POO abarca la capacidad de sobrescribir métodos, sobrecargar métodos y aplicar polimorfismo dinámico. Estos conceptos permiten que los objetos de diferentes clases respondan a las mismas llamadas de métodos de maneras específicas, dependiendo de la implementación de cada clase.

• Sobrecarga de Métodos: Definir múltiples versiones de un método en la misma clase, pero con diferentes parámetros. Aunque JavaScript no soporta sobrecarga de métodos de manera nativa como otros lenguajes (por ejemplo, Java o C++), se puede simular.

• Sobrescritura de Métodos: Modificar la implementación de un método heredado de una clase base en una subclase.

• Polimorfismo Dinámico: Permite que el comportamiento de un método sea determinado en tiempo de ejecución, en lugar de en tiempo de compilación. En JavaScript, esto se logra mediante la sobrescritura de métodos en subclases.

Ejemplos de Polimorfismo Avanzado

1. Sobrecarga de Métodos (Simulada en JavaScript)

Aunque JavaScript no soporta la sobrecarga de métodos de manera nativa, se puede simular mediante el uso de parámetros opcionales y lógica dentro del método.

javascript

class Calculadora {

    // Método sumar con soporte para diferentes números de parámetros

    sumar(a, b, c) {

        if (c !== undefined) {

            return a + b + c;

        } else {

            return a + b;

        }

    }

}

// Crear una instancia de Calculadora

const calculadora = new Calculadora();

console.log(calculadora.sumar(1, 2));       // Output: 3

console.log(calculadora.sumar(1, 2, 3));    // Output: 6

2. Sobrescritura de Métodos

La sobrescritura de métodos es cuando una subclase redefine un método heredado de su superclase. Esto permite que las subclases personalicen o extiendan la funcionalidad de los métodos de la clase base.

javascript

// Clase base Animal

class Animal {

    hacerSonido() {

        console.log("El animal hace un sonido");

    }

}

// Subclase Perro que sobrescribe el método hacerSonido

class Perro extends Animal {

    hacerSonido() {

        console.log("El perro ladra");

    }

}

// Subclase Gato que sobrescribe el método hacerSonido

class Gato extends Animal {

    hacerSonido() {

        console.log("El gato maúlla");

    }

}

// Crear instancias de Perro y Gato

const perro = new Perro();

const gato = new Gato();

perro.hacerSonido(); // Output: El perro ladra

gato.hacerSonido();  // Output: El gato maúlla

3. Polimorfismo Dinámico

El polimorfismo dinámico permite que el comportamiento de los métodos sea determinado en tiempo de ejecución, basándose en el tipo de objeto que invoca el método.

javascript

// Clase base Empleado

class Empleado {

    constructor(nombre, salario) {

        this.nombre = nombre;

        this.salario = salario;

    }

    // Método calcularBono

    calcularBono() {

        return this.salario * 0.1;

    }

    // Método mostrarInfo

    mostrarInfo() {

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

    }

}

// Subclase Gerente que sobrescribe calcularBono

class Gerente extends Empleado {

    calcularBono() {

        return this.salario * 0.2;

    }

}

// Subclase Director que sobrescribe calcularBono

class Director extends Empleado {

    calcularBono() {

        return this.salario * 0.3 + 5000;

    }

}

// Función que aplica polimorfismo dinámico

function mostrarBono(empleado) {

    console.log(`${empleado.nombre} recibirá un bono de ${empleado.calcularBono()}`);

}

// Crear instancias de Empleado, Gerente y Director

const empleado1 = new Empleado('Juan', 30000);

const gerente1 = new Gerente('Ana', 50000);

const director1 = new Director('Carlos', 80000);

// Usar la función mostrarBono para demostrar polimorfismo dinámico

mostrarBono(empleado1);  // Output: Juan recibirá un bono de 3000

mostrarBono(gerente1);   // Output: Ana recibirá un bono de 10000

mostrarBono(director1);  // Output: Carlos recibirá un bono de 29000

Tareas para Practicar

1. Crear una clase Vehiculo con un método mover(). Sobrescribe este método en subclases Coche, Bicicleta, y Barco para que cada subclase tenga una implementación específica del método mover().

2. Simular la sobrecarga de métodos en una clase Matematica con un método multiplicar que acepte dos o tres parámetros.

3. Crear una función que acepte un array de objetos Vehiculo y use polimorfismo dinámico para llamar al método mover() de cada uno, mostrando cómo cada vehículo se mueve de manera diferente.

Ejemplos para Tareas

1. Sobrescritura de Métodos en Subclases de Vehiculo

javascript

// Clase base Vehiculo

class Vehiculo {

    mover() {

        console.log("El vehículo se mueve");

    }

}

// Subclase Coche que sobrescribe mover()

class Coche extends Vehiculo {

    mover() {

        console.log("El coche está conduciendo en la carretera");

    }

}

// Subclase Bicicleta que sobrescribe mover()

class Bicicleta extends Vehiculo {

    mover() {

        console.log("La bicicleta está pedaleando en el carril bici");

    }

}

// Subclase Barco que sobrescribe mover()

class Barco extends Vehiculo {

    mover() {

        console.log("El barco está navegando en el mar");

    }

}

// Crear instancias de las subclases

const coche = new Coche();

const bicicleta = new Bicicleta();

const barco = new Barco();

// Mostrar cómo se mueven los diferentes vehículos

coche.mover();      // Output: El coche está conduciendo en la carretera

bicicleta.mover();  // Output: La bicicleta está pedaleando en el carril bici

barco.mover();      // Output: El barco está navegando en el mar

2. Simulación de Sobrecarga de Métodos en Matematica

javascript

// Clase Matematica con simulación de sobrecarga en multiplicar

class Matematica {

    multiplicar(a, b, c) {

        if (c !== undefined) {

            return a * b * c;

        } else {

            return a * b;

        }

    }

}

// Crear una instancia de Matematica

const matematica = new Matematica();

console.log(matematica.multiplicar(2, 3));      // Output: 6

console.log(matematica.multiplicar(2, 3, 4));   // Output: 24

3. Uso de Polimorfismo Dinámico con Vehiculo

javascript

// Función que usa polimorfismo dinámico para mover diferentes vehículos

function moverVehiculos(vehiculos) {

    vehiculos.forEach(vehiculo => {

        vehiculo.mover();

    });

}

// Crear un array de objetos Vehiculo (Coche, Bicicleta, Barco)

const vehiculos = [new Coche(), new Bicicleta(), new Barco()];

// Mover todos los vehículos usando polimorfismo dinámico

moverVehiculos(vehiculos);

// Output:

// El coche está conduciendo en la carretera

// La bicicleta está pedaleando en el carril bici

// El barco está navegando en el mar

Notas

El polimorfismo avanzado es una técnica poderosa en POO que permite escribir código más flexible y reutilizable. La sobrescritura de métodos, la simulación de sobrecarga de métodos y el polimorfismo dinámico son herramientas esenciales para crear sistemas más dinámicos y adaptables.

¡Practica estos conceptos para afianzar tu comprensión y aplicarlos en proyectos más complejos!

Conceptos Clave

1. Clases Abstractas:

   • No se pueden instanciar directamente.

   • Pueden contener métodos abstractos (sin implementación) y métodos concretos (con implementación).

   • Se utilizan como base para otras clases.

2. Interfaces:

   • Son una colección de métodos que una clase debe implementar.

   • En JavaScript, no hay soporte directo para interfaces, pero se puede simular con clases abstractas o convenciones.

Diferencias

1. Instanciación:

   • Clases Abstractas: No se pueden instanciar directamente.

   • Interfaces: No se pueden instanciar, solo se implementan.

2. Herencia/Implementación:

   • Clases Abstractas: Una clase puede heredar de una sola clase abstracta.

   • Interfaces: Una clase puede implementar múltiples interfaces.

3. Métodos:

   • Clases Abstractas: Pueden tener métodos con implementación.

   • Interfaces: No tienen implementación de métodos (en lenguajes que soportan interfaces directamente).

Ejemplo en JavaScript: Clases Abstractas

Aunque JavaScript no soporta directamente las clases abstractas como otros lenguajes (por ejemplo, Java), podemos simularlas usando clases base con métodos que lanzan errores si no son implementados por subclases.

// Definición de una clase abstracta Animal

class Animal {

  constructor(nombre) {

    if (this.constructor === Animal) {

      throw new Error('No se puede instanciar una clase abstracta.');

    }

    this.nombre = nombre;

  }

  // Método abstracto

  hacerSonido() {

    throw new Error('Debe implementar el método hacerSonido.');

  }

}

// Definición de la clase Perro que extiende Animal

class Perro extends Animal {

  hacerSonido() {

    console.log(`${this.nombre} ladra.`);

  }

}

// Definición de la clase Gato que extiende Animal

class Gato extends Animal {

  hacerSonido() {

    console.log(`${this.nombre} maúlla.`);

  }

}

// Crear objetos de las clases derivadas

const perro = new Perro('Rex');

const gato = new Gato('Misu');

// Usar los métodos

perro.hacerSonido(); // Output: Rex ladra.

gato.hacerSonido();  // Output: Misu maúlla.

En este ejemplo:

• La clase Animal actúa como una clase abstracta.

• Si intentamos crear una instancia de Animal, se lanzará un error.

• Los métodos abstractos (hacerSonido) deben ser implementados por las subclases (Perro y Gato).

Ejemplo en JavaScript: Simulando Interfaces

Como JavaScript no tiene soporte nativo para interfaces, podemos usar clases y convenciones para simular su comportamiento.

// Definición de la "interfaz" Vehiculo

class Vehiculo {

  // Método "interfaz" debe ser implementado

  arrancar() {

    throw new Error('Debe implementar el método arrancar.');

  }

  // Método "interfaz" debe ser implementado

  detener() {

    throw new Error('Debe implementar el método detener.');

  }

}

// Clase Coche que implementa la "interfaz" Vehiculo

class Coche extends Vehiculo {

  arrancar() {

    console.log('El coche ha arrancado.');

  }

  detener() {

    console.log('El coche se ha detenido.');

  }

}

// Clase Bicicleta que implementa la "interfaz" Vehiculo

class Bicicleta extends Vehiculo {

  arrancar() {

    console.log('La bicicleta ha empezado a moverse.');

  }

  detener() {

    console.log('La bicicleta se ha detenido.');

  }

}

// Crear objetos de las clases

const coche = new Coche();

const bicicleta = new Bicicleta();

// Usar los métodos

coche.arrancar();      // Output: El coche ha arrancado.

coche.detener();       // Output: El coche se ha detenido.

bicicleta.arrancar();  // Output: La bicicleta ha empezado a moverse.

bicicleta.detener();   // Output: La bicicleta se ha detenido.

En este ejemplo:

• La clase Vehiculo actúa como una "interfaz".

• Las clases Coche y Bicicleta implementan los métodos arrancar y detener definidos en la "interfaz".

Cuándo Usar Cada Una

1. Clases Abstractas:

   • Cuando se tiene una funcionalidad base común y se quiere asegurar que ciertas clases deben implementar métodos específicos.

   • Cuando se desea proporcionar alguna implementación común a las subclases.

2. Interfaces (simuladas en JavaScript):

   • Cuando se desea definir un contrato que varias clases deben seguir sin proporcionar ninguna implementación común.

   • Cuando se necesita soportar múltiples herencias de comportamiento.

Ejercicio

Crea una clase abstracta Instrumento con un método abstracto tocar. Luego, crea dos subclases Guitarra y Piano que implementen el método tocar.

// Definición de la clase abstracta Instrumento

class Instrumento {

  constructor(nombre) {

    if (this.constructor === Instrumento) {

      throw new Error('No se puede instanciar una clase abstracta.');

    }

    this.nombre = nombre;

  }

  // Método abstracto

  tocar() {

    throw new Error('Debe implementar el método tocar.');

  }

}

// Clase Guitarra que extiende Instrumento

class Guitarra extends Instrumento {

  tocar() {

    console.log(`La ${this.nombre} está siendo tocada.`);

  }

}

// Clase Piano que extiende Instrumento

class Piano extends Instrumento {

  tocar() {

    console.log(`El ${this.nombre} está siendo tocado.`);

  }

}

// Crear objetos de las clases derivadas

const guitarra = new Guitarra('guitarra');

const piano = new Piano('piano');

// Usar los métodos

guitarra.tocar(); // Output: La guitarra está siendo tocada.

piano.tocar();    // Output: El piano está siendo tocado.

Estos ejercicios y ejemplos te ayudarán a comprender mejor las diferencias y usos de las clases abstractas e interfaces en la Programación Orientada a Objetos con JavaScript. ¡Sigue practicando y explorando! Mañana continuaremos con más principios de diseño.

Conceptos Clave

Herencia y composición son dos formas de reutilizar código en la Programación Orientada a Objetos (POO).

• Herencia: Permite que una clase (subclase) herede propiedades y métodos de otra clase (superclase). Es útil cuando hay una clara relación jerárquica entre las clases (por ejemplo, un perro es un animal).

• Composición: Consiste en construir clases a partir de otras clases, es decir, una clase contiene instancias de otras clases. Es útil cuando se desea crear clases complejas a partir de componentes más pequeños y reutilizables (por ejemplo, un coche tiene un motor).

Diferencias

1. Herencia:

   • Representa una relación "es-un".

   • Facilita la reutilización de código a través de la herencia.

   • Puede llevar a un acoplamiento fuerte entre las clases.

   • Puede resultar en jerarquías de clases complejas y difíciles de mantener.

2. Composición:

   • Representa una relación "tiene-un".

   • Facilita la reutilización de código a través de la agregación de componentes.

   • Promueve un acoplamiento más flexible y modular.

   • Facilita el mantenimiento y la escalabilidad del sistema.

Ejemplo en JavaScript: Herencia

Supongamos que tenemos una clase Animal y queremos crear una subclase Perro que herede de Animal.

// Definición de la clase base Animal

class Animal {

  constructor(nombre) {

    this.nombre = nombre;

  }

  hacerSonido() {

    console.log(`${this.nombre} hace un sonido.`);

  }

}

// Definición de la clase derivada Perro

class Perro extends Animal {

  hacerSonido() {

    console.log(`${this.nombre} ladra.`);

  }

}

// Crear un objeto de la clase Perro

const perro = new Perro('Rex');

perro.hacerSonido(); // Output: Rex ladra.

En este ejemplo:

• Perro hereda de Animal, lo que significa que Perro es un tipo de Animal.

• Perro sobrescribe el método hacerSonido.

Ejemplo en JavaScript: Composición

Supongamos que queremos crear una clase Coche que tenga un motor (Motor), ruedas (Rueda), y un sistema de entretenimiento (Entretenimiento).

// Definición de la clase Motor

class Motor {

  encender() {

    console.log('El motor está encendido.');

  }

  apagar() {

    console.log('El motor está apagado.');

  }

}

// Definición de la clase Rueda

class Rueda {

  inflar() {

    console.log('La rueda está inflada.');

  }

  desinflar() {

    console.log('La rueda está desinflada.');

  }

}

// Definición de la clase Entretenimiento

class Entretenimiento {

  encender() {

    console.log('El sistema de entretenimiento está encendido.');

  }

  apagar() {

    console.log('El sistema de entretenimiento está apagado.');

  }

}

// Definición de la clase Coche que usa composición

class Coche {

  constructor() {

    this.motor = new Motor();

    this.ruedas = [new Rueda(), new Rueda(), new Rueda(), new Rueda()];

    this.entretenimiento = new Entretenimiento();

  }

  encenderCoche() {

    this.motor.encender();

    this.entretenimiento.encender();

    this.ruedas.forEach(rueda => rueda.inflar());

    console.log('El coche está encendido.');

  }

  apagarCoche() {

    this.motor.apagar();

    this.entretenimiento.apagar();

    this.ruedas.forEach(rueda => rueda.desinflar());

    console.log('El coche está apagado.');

  }

}

// Crear un objeto de la clase Coche

const coche = new Coche();

coche.encenderCoche();

// Output:

// El motor está encendido.

// El sistema de entretenimiento está encendido.

// La rueda está inflada.

// La rueda está inflada.

// La rueda está inflada.

// La rueda está inflada.

// El coche está encendido.

coche.apagarCoche();

// Output:

// El motor está apagado.

// El sistema de entretenimiento está apagado.

// La rueda está desinflada.

// La rueda está desinflada.

// La rueda está desinflada.

// La rueda está desinflada.

// El coche está apagado.

En este ejemplo:

• La clase Coche está compuesta de instancias de Motor, Rueda, y Entretenimiento.

• Esto permite construir la funcionalidad del coche a partir de componentes reutilizables.

Cuándo Usar Composición en Lugar de Herencia

1. Preferir Composición sobre Herencia:

   • Cuando la relación no es naturalmente jerárquica.

   • Cuando se desea mayor flexibilidad y modularidad.

   • Cuando se desea evitar las limitaciones de la herencia múltiple (no soportada directamente en muchos lenguajes).

2. Usar Herencia:

   • Cuando hay una clara relación "es-un".

   • Cuando se necesita reutilizar código común en subclases.

Ejercicio

Crea una clase Casa que tenga Puertas, Ventanas, y Habitaciones. Implementa los métodos abrirPuertas, cerrarVentanas, y encenderLuces.

• Clase Puerta:

  • Métodos: abrir, cerrar.

• Clase Ventana:

  • Métodos: abrir, cerrar.

• Clase Habitacion:

  • Métodos: encenderLuz, apagarLuz.

• Clase Casa:

  • Atributos: puertas, ventanas, habitaciones.

  • Métodos: abrirPuertas, cerrarVentanas, encenderLuces.

// Definición de la clase Puerta

class Puerta {

  abrir() {

    console.log('La puerta está abierta.');

  }

  cerrar() {

    console.log('La puerta está cerrada.');

  }

}

// Definición de la clase Ventana

class Ventana {

  abrir() {

    console.log('La ventana está abierta.');

  }

  cerrar() {

    console.log('La ventana está cerrada.');

  }

}

// Definición de la clase Habitacion

class Habitacion {

  encenderLuz() {

    console.log('La luz de la habitación está encendida.');

  }

  apagarLuz() {

    console.log('La luz de la habitación está apagada.');

  }

}

// Definición de la clase Casa que usa composición

class Casa {

  constructor() {

    this.puertas = [new Puerta(), new Puerta(), new Puerta()];

    this.ventanas = [new Ventana(), new Ventana(), new Ventana(), new Ventana()];

    this.habitaciones = [new Habitacion(), new Habitacion(), new Habitacion()];

  }

  abrirPuertas() {

    this.puertas.forEach(puerta => puerta.abrir());

  }

  cerrarVentanas() {

    this.ventanas.forEach(ventana => ventana.cerrar());

  }

  encenderLuces() {

    this.habitaciones.forEach(habitacion => habitacion.encenderLuz());

  }

}

// Crear un objeto de la clase Casa

const casa = new Casa();

casa.abrirPuertas();

// Output:

// La puerta está abierta.

// La puerta está abierta.

// La puerta está abierta.

casa.cerrarVentanas();

// Output:

// La ventana está cerrada.

// La ventana está cerrada.

// La ventana está cerrada.

// La ventana está cerrada.

casa.encenderLuces();

// Output:

// La luz de la habitación está encendida.

// La luz de la habitación está encendida.

// La luz de la habitación está encendida.

Estos ejercicios y ejemplos te ayudarán a entender mejor cuándo usar composición y cuándo usar herencia en la Programación Orientada a Objetos. ¡Sigue practicando y explorando! Mañana continuaremos con más principios de diseño.

Introducción a los Principios SOLID

Los principios SOLID son un conjunto de cinco principios de diseño que guían a los desarrolladores a crear software más flexible, escalable, y fácil de mantener. Estos principios fueron formulados por Robert C. Martin, también conocido como "Uncle Bob". En esta primera parte, nos enfocaremos en los dos primeros principios: Single Responsibility Principle (SRP) y Open/Closed Principle (OCP).

1. Single Responsibility Principle (SRP)

El principio de responsabilidad única (SRP) establece que una clase debe tener una sola razón para cambiar, lo que significa que debe tener una única responsabilidad o propósito. Este principio promueve la cohesión en las clases y facilita el mantenimiento y la reutilización del código.

Ejemplo de Violación de SRP

javascript

class Reporte {

    constructor(datos) {

        this.datos = datos;

    }

    // Método para generar el reporte

    generarReporte() {

        // Lógica para generar el reporte

        console.log("Generando reporte con los datos:", this.datos);

    }

    // Método para imprimir el reporte

    imprimirReporte() {

        // Lógica para imprimir el reporte

        console.log("Imprimiendo reporte...");

    }

    // Método para guardar el reporte en un archivo

    guardarReporte(rutaArchivo) {

        // Lógica para guardar el reporte en un archivo

        console.log(`Guardando el reporte en ${rutaArchivo}`);

    }

}

En este ejemplo, la clase Reporte tiene múltiples responsabilidades: generar, imprimir y guardar un reporte. Esto viola el principio SRP.

Refactorización para Cumplir SRP

javascript

class Reporte {

    constructor(datos) {

        this.datos = datos;

    }

    // Método para generar el reporte

    generarReporte() {

        console.log("Generando reporte con los datos:", this.datos);

    }

}

class Impresora {

    imprimir(reporte) {

        console.log("Imprimiendo reporte...");

    }

}

class Guardador {

    guardar(reporte, rutaArchivo) {

        console.log(`Guardando el reporte en ${rutaArchivo}`);

    }

}

// Uso de las clases refactorizadas

const reporte = new Reporte("Datos importantes");

const impresora = new Impresora();

const guardador = new Guardador();

reporte.generarReporte();

impresora.imprimir(reporte);

guardador.guardar(reporte, "reporte.txt");

Ahora, cada clase tiene una única responsabilidad: Reporte genera el reporte, Impresora lo imprime, y Guardador lo guarda, cumpliendo con SRP.

2. Open/Closed Principle (OCP)

El principio de abierto/cerrado (OCP) establece que una clase debe estar abierta para su extensión pero cerrada para su modificación. Esto significa que deberías poder extender el comportamiento de una clase sin modificar su código fuente original.

Ejemplo de Violación de OCP

javascript

class Calculadora {

    calcular(operacion, a, b) {

        if (operacion === "sumar") {

            return a + b;

        } else if (operacion === "restar") {

            return a - b;

        } else if (operacion === "multiplicar") {

            return a * b;

        } else if (operacion === "dividir") {

            return a / b;

        }

    }

}

const calculadora = new Calculadora();

console.log(calculadora.calcular("sumar", 5, 3)); // Output: 8

En este ejemplo, cada vez que se necesite una nueva operación, tendríamos que modificar la clase Calculadora, violando el principio OCP.

Refactorización para Cumplir OCP

javascript

// Clase base Operacion

class Operacion {

    calcular(a, b) {

        throw new Error("Este método debe ser implementado por subclases");

    }

}

// Subclases para cada operación

class Sumar extends Operacion {

    calcular(a, b) {

        return a + b;

    }

}

class Restar extends Operacion {

    calcular(a, b) {

        return a - b;

    }

}

class Calculadora {

    realizarCalculo(operacion, a, b) {

        return operacion.calcular(a, b);

    }

}

// Uso de las clases refactorizadas

const calculadora = new Calculadora();

console.log(calculadora.realizarCalculo(new Sumar(), 5, 3)); // Output: 8

console.log(calculadora.realizarCalculo(new Restar(), 5, 3)); // Output: 2

Ahora, la clase Calculadora está cerrada para modificaciones pero abierta para extensiones, ya que podemos añadir nuevas operaciones creando nuevas subclases de Operacion.

Continuación de los Principios SOLID

En esta segunda parte, cubriremos los tres principios restantes: Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), y Dependency Inversion Principle (DIP).

3. Liskov Substitution Principle (LSP)

El principio de sustitución de Liskov (LSP) establece que las subclases deben ser sustituibles por sus clases base sin alterar el correcto funcionamiento del programa. En otras palabras, si S es una subclase de T, entonces los objetos de tipo T en un programa deberían poder ser reemplazados por objetos de tipo S sin modificar el comportamiento esperado.

Ejemplo de Violación de LSP

javascript

class Rectangulo {

    constructor(ancho, alto) {

        this.ancho = ancho;

        this.alto = alto;

    }

    calcularArea() {

        return this.ancho * this.alto;

    }

}

class Cuadrado extends Rectangulo {

    constructor(lado) {

        super(lado, lado);

    }

    setAncho(ancho) {

        this.ancho = this.alto = ancho;

    }

    setAlto(alto) {

        this.ancho = this.alto = alto;

    }

}

function imprimirArea(rectangulo) {

    rectangulo.setAncho(5);

    rectangulo.setAlto(4);

    console.log(rectangulo.calcularArea());

}

const rectangulo = new Rectangulo(2, 3);

const cuadrado = new Cuadrado(5);

imprimirArea(rectangulo); // Output: 20

imprimirArea(cuadrado);   // Output: 16 (incorrecto)

En este ejemplo, la subclase Cuadrado rompe el LSP porque no se comporta de la misma manera que Rectangulo. Cuando tratamos Cuadrado como un Rectangulo, obtenemos resultados incorrectos.

Cumplimiento de LSP

Para cumplir con LSP, Cuadrado no debería heredar de Rectangulo si no puede cumplir con su comportamiento esperado. En su lugar, podemos replantear el diseño:

javascript

class Cuadrado {

    constructor(lado) {

        this.lado = lado;

    }

    calcularArea() {

        return this.lado * this.lado;

    }

}

// Uso adecuado sin herencia incorrecta

const cuadrado = new Cuadrado(5);

console.log(cuadrado.calcularArea()); // Output: 25

4. Interface Segregation Principle (ISP)

El principio de segregación de interfaces (ISP) establece que los clientes no deberían verse forzados a depender de interfaces que no utilizan. Es mejor tener muchas interfaces específicas y pequeñas que una única interfaz general y grande.

Ejemplo de Violación de ISP

javascript

class Trabajador {

    trabajar() {

        // Implementación

    }

    comer() {

        // Implementación

    }

    dormir() {

        // Implementación

    }

}

class Robot extends Trabajador {

    dormir() {

        // Los robots no duermen, pero aún tienen que implementar este método

        throw new Error("Los robots no duermen");

    }

}

Aquí, Robot se ve forzado a implementar un método dormir que no necesita, violando ISP.

Refactorización para Cumplir ISP

javascript

// Interfaces específicas

class Trabajador {

    trabajar() {

        // Implementación

    }

}

class SerHumano extends Trabajador {

    comer() {

        // Implementación

    }

    dormir() {

        // Implementación

    }

}

class Robot extends Trabajador {

    // Sin necesidad de implementar métodos innecesarios

}

// Uso adecuado

const humano = new SerHumano();

const robot = new Robot();

humano.trabajar();

humano.dormir();

robot.trabajar();

Ahora, Robot solo depende de la interfaz que realmente utiliza.

5. Dependency Inversion Principle (DIP)

El principio de inversión de dependencias (DIP) establece que las clases de alto nivel no deberían depender de clases de bajo nivel, sino de abstracciones. Además, las abstracciones no deberían depender de los detalles; los detalles deberían depender de las abstracciones.

Ejemplo de Violación de DIP

javascript

class Motor {

    encender() {

        console.log("Motor encendido");

    }

}

class Coche {

    constructor() {

        this.motor = new Motor();

    }

    arrancar() {

        this.motor.encender();

    }

}

Aquí, Coche depende directamente de la clase Motor, lo que dificulta cambiar el tipo de motor en el futuro.

Refactorización para Cumplir DIP

javascript

// Abstracción del Motor

class IMotor {

    encender() {

        throw new Error("Este método debe ser implementado por subclases");

    }

}

// Implementaciones de motores específicos

class MotorGasolina extends IMotor {

    encender() {

        console.log("Motor de gasolina encendido");

    }

}

class MotorElectrico extends IMotor {

    encender() {

        console.log("Motor eléctrico encendido");

    }

}

// Clase Coche que depende de la abstracción

class Coche {

    constructor(motor) {

        this.motor = motor;

    }

    arrancar() {

        this.motor.encender();

    }

}

// Uso adecuado

const cocheGasolina = new Coche(new MotorGasolina());

cocheGasolina.arrancar(); // Output: Motor de gasolina encendido

const cocheElectrico = new Coche(new MotorElectrico());

cocheElectrico.arrancar(); // Output: Motor eléctrico encendido

Ahora, Coche depende de la abstracción IMotor, lo que facilita cambiar el tipo de motor sin modificar la clase Coche.

Notas

Los principios SOLID son fundamentales para escribir código robusto, mantenible y extensible. Aplicando estos principios, puedes diseñar sistemas de software que sean más fáciles de entender, modificar y escalar. A medida que practiques y apliques estos principios, mejorarás significativamente la calidad de tu código.

¡Esto concluye nuestra sesión sobre los principios SOLID! Continúa practicando estos conceptos en tus proyectos para internalizarlos completamente.

REPASO de Conceptos Avanzados

Hoy es un día dedicado a repasar los conceptos avanzados que hemos cubierto en los últimos días y a poner a prueba tu comprensión con un cuestionario. Repasaremos los principios SOLID y los conceptos de polimorfismo avanzado, herencia avanzada, sobrecarga y sobrescritura de métodos.

1. Repaso de los Principios SOLID

• Single Responsibility Principle (SRP): Una clase debe tener una única responsabilidad, o razón para cambiar.

• Open/Closed Principle (OCP): Las clases deben estar abiertas para extensión pero cerradas para modificación.

• Liskov Substitution Principle (LSP): Las subclases deben poder reemplazar a sus clases base sin alterar el comportamiento del programa.

• Interface Segregation Principle (ISP): Los clientes no deberían estar forzados a depender de interfaces que no utilizan.

• Dependency Inversion Principle (DIP): Las clases de alto nivel no deben depender de clases de bajo nivel; ambas deben depender de abstracciones.

2. Repaso de Polimorfismo Avanzado

• Sobrecarga de Métodos: Crear múltiples métodos con el mismo nombre pero con diferentes parámetros. Aunque JavaScript no lo soporta de manera nativa, se puede simular.

• Sobrescritura de Métodos: Permitir que una subclase provea una implementación específica de un método que ya existe en su superclase.

• Polimorfismo Dinámico: La habilidad de invocar métodos en objetos de subclases a través de referencias a la clase base, permitiendo que el comportamiento específico se determine en tiempo de ejecución.

3. Repaso de Herencia Avanzada

• Herencia en Profundidad: Crear jerarquías de clases donde una subclase hereda de otra subclase.

• Composición vs. Herencia: Usar composición cuando una relación "tiene un" es más adecuada que una relación "es un" para evitar problemas de rigidez en las jerarquías de herencia.

4. Cuestionario (Quiz)

Ahora, pongamos a prueba lo que has aprendido. A continuación, te presento un conjunto de preguntas de opción múltiple y ejercicios de código para que evalúes tu comprensión.

Parte 1: Preguntas de Opción Múltiple

1. ¿Qué principio SOLID se viola si una clase tiene múltiples responsabilidades?

   • a) Open/Closed Principle

   • b) Liskov Substitution Principle

   • c) Single Responsibility Principle

   • d) Interface Segregation Principle

2. ¿Cuál de las siguientes afirmaciones describe mejor el principio Open/Closed?

   • a) Una clase debe tener una sola responsabilidad.

   • b) Una clase debe estar abierta a modificación y cerrada a extensión.

   • c) Una clase debe estar abierta a extensión pero cerrada a modificación.

   • d) Una clase debe implementar múltiples interfaces pequeñas.

3. Si una subclase no puede sustituir a su superclase sin romper la funcionalidad del programa, ¿qué principio SOLID se está violando?

   • a) Dependency Inversion Principle

   • b) Liskov Substitution Principle

   • c) Single Responsibility Principle

   • d) Interface Segregation Principle

4. En el contexto de la herencia, ¿qué significa sobrescribir un método?

   • a) Crear un nuevo método con el mismo nombre pero diferente número de parámetros.

   • b) Redefinir un método heredado en una subclase para cambiar su comportamiento.

   • c) Crear un método con el mismo nombre en la misma clase pero diferente retorno.

   • d) Definir un método sin implementación en una clase base.

5. ¿Qué es la sobrecarga de métodos?

   • a) Definir varios métodos con el mismo nombre pero diferentes firmas en la misma clase.

   • b) Reutilizar un método de una clase base en una subclase.

   • c) Evitar la implementación de métodos en clases abstractas.

   • d) Crear métodos que solo pueden ser llamados desde la clase base.

Parte 2: Ejercicios de Código

1. Refactoriza el siguiente código para que cumpla con el principio de responsabilidad única (SRP):
   
   

javascript
class Usuario {

    constructor(nombre, email, password) {

        this.nombre = nombre;

        this.email = email;

        this.password = password;

    }

    registrar() {

        console.log(`Registrando usuario: ${this.nombre}`);

        this.enviarEmail();

    }

    enviarEmail() {

        console.log(`Enviando correo de confirmación a ${this.email}`);

    }

}

2. Corrige el siguiente código para que cumpla con el principio Liskov Substitution (LSP):

javascript
Copiar código
class Pajaro {

    volar() {

        console.log("El pájaro está volando");

    }

}

class Pinguino extends Pajaro {

    volar() {

        throw new Error("Los pingüinos no pueden volar");

    }

}

const pinguino = new Pinguino();

pinguino.volar(); // Error: Los pingüinos no pueden volar

3. Aplica el principio de inversión de dependencias (DIP) al siguiente código:
   
   

javascript
class MySQLDatabase {

    conectar() {

        console.log("Conectando a la base de datos MySQL");

    }

}

class Aplicacion {

    constructor() {

        this.database = new MySQLDatabase();

    }

    iniciar() {

        this.database.conectar();

    }

}

const app = new Aplicacion();

app.iniciar(); // Output: Conectando a la base de datos MySQL

Respuestas al Quiz (NO MIRAR SIN INTENTAR RESOLVER ANTES!!!!)

Parte 1: Preguntas de Opción Múltiple

1. c) Single Responsibility Principle

2. c) Una clase debe estar abierta a extensión pero cerrada a modificación.

3. b) Liskov Substitution Principle

4. b) Redefinir un método heredado en una subclase para cambiar su comportamiento.

5. a) Definir varios métodos con el mismo nombre pero diferentes firmas en la misma clase.

Parte 2: Ejercicios de Código

1 Refactorización SRP:
javascript
class Usuario {

    constructor(nombre, email, password) {

        this.nombre = nombre;

        this.email = email;

        this.password = password;

    }

    registrar() {

        console.log(`Registrando usuario: ${this.nombre}`);

    }

}

class EmailService {

    enviarEmail(email) {

        console.log(`Enviando correo de confirmación a ${email}`);

    }

}

const usuario = new Usuario('Juan', 'juan@example.com', 'password123');

const emailService = new EmailService();

usuario.registrar();

emailService.enviarEmail(usuario.email);

2 Cumplimiento de LSP:
javascript
class Ave {

    moverse() {

        console.log("El ave se está moviendo");

    }

}

class Pinguino extends Ave {

    moverse() {

        console.log("El pingüino está caminando o nadando");

    }

}

const pinguino = new Pinguino();

pinguino.moverse(); // Output: El pingüino está caminando o nadando

3 Cumplimiento de DIP:
javascript
class Database {

    conectar() {

        throw new Error("Este método debe ser implementado por subclases");

    }

}

class MySQLDatabase extends Database {

    conectar() {

        console.log("Conectando a la base de datos MySQL");

    }

}

class Aplicacion {

    constructor(database) {

        this.database = database;

    }

    iniciar() {

        this.database.conectar();

    }

}

const database = new MySQLDatabase();

const app = new Aplicacion(database);

app.iniciar(); // Output: Conectando a la base de datos MySQL

Notas

Este repaso y cuestionario deberían ayudarte a consolidar tu comprensión de los conceptos avanzados de POO y los principios SOLID. Continúa practicando para dominar estos principios y aplicarlos de manera efectiva en tus proyectos de software. ¡Buen trabajo!

¿Qué son los Patrones de Diseño?

Los patrones de diseño son soluciones reutilizables y probadas a problemas comunes que surgen en el diseño de software. Estos patrones son descripciones o plantillas que se pueden aplicar a situaciones específicas para resolver problemas de diseño de forma eficaz. Se dividen en tres categorías principales:

1. Patrones Creacionales: Se enfocan en la forma en que se crean los objetos.

2. Patrones Estructurales: Se enfocan en la composición de clases u objetos.

3. Patrones de Comportamiento: Se enfocan en la interacción y responsabilidad entre clases y objetos.

¿Por qué son Útiles los Patrones de Diseño?

1. Reutilización de Soluciones: Proporcionan soluciones probadas y comprobadas a problemas comunes, evitando la necesidad de reinventar la rueda.

2. Estandarización: Ayudan a estandarizar el diseño de software, facilitando la comunicación entre desarrolladores.

3. Mantenimiento y Escalabilidad: Facilitan el mantenimiento y la escalabilidad del código al seguir estructuras claras y bien definidas.

4. Buenas Prácticas: Promueven buenas prácticas de diseño y programación, mejorando la calidad del software.

Ejemplo de un Patrón de Diseño: Singleton

El patrón Singleton es un patrón creacional que garantiza que una clase solo tenga una instancia y proporciona un punto de acceso global a esa instancia.

// Implementación del patrón Singleton en JavaScript

class Singleton {

  constructor() {

    if (Singleton.instance) {

      return Singleton.instance;

    }

    Singleton.instance = this;

  }

  someMethod() {

    console.log('Método de la instancia Singleton');

  }

}

// Intentar crear múltiples instancias

const instance1 = new Singleton();

const instance2 = new Singleton();

console.log(instance1 === instance2); // Output: true

instance1.someMethod(); // Output: Método de la instancia Singleton

instance2.someMethod(); // Output: Método de la instancia Singleton

En este ejemplo:

• La clase Singleton se asegura de que solo exista una instancia de sí misma.

• Cualquier intento de crear una nueva instancia devolverá la instancia existente.

Ejercicio

1. Identifica un Problema Común: Piensa en un problema común que has enfrentado en tus proyectos de software.

2. Selecciona un Patrón: Selecciona un patrón de diseño que pueda resolver ese problema.

3. Implementa el Patrón: Implementa el patrón de diseño en JavaScript para resolver el problema identificado.

Ejemplo de Ejercicio

Problema Común: Necesitas asegurar que una clase de configuración solo tenga una instancia para evitar conflictos en la configuración.

Patrón Seleccionado: Singleton

Implementación del Patrón:

class Configuracion {

  constructor() {

    if (Configuracion.instance) {

      return Configuracion.instance;

    }

    this.settings = {};

    Configuracion.instance = this;

  }

  set(key, value) {

    this.settings[key] = value;

  }

  get(key) {

    return this.settings[key];

  }

}

// Crear una única instancia de Configuracion

const config1 = new Configuracion();

const config2 = new Configuracion();

config1.set('theme', 'dark');

console.log(config2.get('theme')); // Output: dark

console.log(config1 === config2); // Output: true

En este ejercicio:

• Implementamos el patrón Singleton para la clase Configuracion.

• Aseguramos que solo haya una instancia de Configuracion.

• La configuración establecida en config1 es accesible a través de config2, demostrando que ambos son la misma instancia.

Conclusión