TypeScript: Programación Orientada a Objetos

La programación orientada a objetos (POO) es un paradigma de programación que utiliza "objetos" para modelar datos y comportamientos. TypeScript, siendo un superconjunto tipado de JavaScript, proporciona soporte robusto para POO, permitiendo a los desarrolladores crear aplicaciones más estructuradas y mantenibles. En este módulo, exploraremos los conceptos fundamentales de POO en TypeScript.

Clases y objetos

Las clases son la piedra angular de la POO. En TypeScript, se definen utilizando la palabra clave class. Una clase puede contener propiedades y métodos que definen el estado y el comportamiento de los objetos creados a partir de ella.

class Persona {
    nombre: string;
    edad: number;

    constructor(nombre: string, edad: number) {
        this.nombre = nombre;
        this.edad = edad;
    }

    saludar(): void {
        console.log(`Hola, me llamo ${this.nombre} y tengo ${this.edad} años.`);
    }
}

const persona1 = new Persona('Juan', 30);
persona1.saludar(); // Hola, me llamo Juan y tengo 30 años.

Herencia

La herencia permite crear nuevas clases basadas en clases existentes. En TypeScript, se utiliza la palabra clave extends para indicar que una clase hereda de otra.

class Empleado extends Persona {
    salario: number;

    constructor(nombre: string, edad: number, salario: number) {
        super(nombre, edad);
        this.salario = salario;
    }

    mostrarSalario(): void {
        console.log(`El salario es ${this.salario} euros.`);
    }
}

const empleado1 = new Empleado('Ana', 28, 30000);
empleado1.saludar(); // Hola, me llamo Ana y tengo 28 años.
empleado1.mostrarSalario(); // El salario es 30000 euros.

Encapsulamiento

El encapsulamiento es el mecanismo que restringe el acceso directo a algunos componentes del objeto. En TypeScript, se utilizan los modificadores de acceso public, private y protected.

class CuentaBancaria {
    private saldo: number;

    constructor(saldoInicial: number) {
        this.saldo = saldoInicial;
    }

    depositar(cantidad: number): void {
        this.saldo += cantidad;
    }

    retirar(cantidad: number): void {
        if (cantidad <= this.saldo) {
            this.saldo -= cantidad;
        } else {
            console.log('Fondos insuficientes.');
        }
    }

    mostrarSaldo(): void {
        console.log(`El saldo es ${this.saldo} euros.`);
    }
}

const cuenta = new CuentaBancaria(1000);
cuenta.depositar(500);
cuenta.retirar(200);
cuenta.mostrarSaldo(); // El saldo es 1300 euros.

Polimorfismo

El polimorfismo permite a los objetos de diferentes clases ser tratados como objetos de una clase común. Esto se logra mediante la herencia y la sobreescritura de métodos.

class Animal {
    hacerSonido(): void {
        console.log('Sonido genérico de animal');
    }
}

class Perro extends Animal {
    hacerSonido(): void {
        console.log('Guau Guau');
    }
}

class Gato extends Animal {
    hacerSonido(): void {
        console.log('Miau Miau');
    }
}

const animales: Animal[] = [new Perro(), new Gato()];
animales.forEach(animal => animal.hacerSonido());
// Guau Guau
// Miau Miau

Interfaces

Las interfaces en TypeScript son una forma de definir contratos dentro de tu código. Las clases que implementan una interfaz deben cumplir con su estructura.

interface Volador {
    volar(): void;
}

class Pajaro implements Volador {
    volar(): void {
        console.log('El pájaro está volando.');
    }
}

class Avion implements Volador {
    volar(): void {
        console.log('El avión está volando.');
    }
}

const voladores: Volador[] = [new Pajaro(), new Avion()];
voladores.forEach(volador => volador.volar());
// El pájaro está volando.
// El avión está volando.