Programación Orientada a Objetos en TypeScript

La programación orientada a objetos (POO) representa uno de los paradigmas más influyentes en el desarrollo de software moderno. TypeScript, como superset de JavaScript, incorpora características avanzadas de POO que permiten crear aplicaciones más estructuradas, mantenibles y escalables.

Fundamentos de la orientación a objetos

La POO se basa en la organización del código alrededor de objetos que encapsulan datos y comportamientos relacionados. Este enfoque permite modelar problemas del mundo real de manera más intuitiva, donde cada objeto representa una entidad con características específicas y capacidades definidas.

En TypeScript, la POO se materializa a través de clases, que actúan como plantillas para crear objetos. Una clase define la estructura y el comportamiento que compartirán todas las instancias creadas a partir de ella.

class Vehiculo {
    marca: string;
    modelo: string;
    
    constructor(marca: string, modelo: string) {
        this.marca = marca;
        this.modelo = modelo;
    }
    
    arrancar(): void {
        console.log(`${this.marca} ${this.modelo} está arrancando`);
    }
}

Pilares fundamentales

Encapsulación

La encapsulación permite controlar el acceso a los datos internos de una clase mediante modificadores de visibilidad. TypeScript ofrece tres niveles de acceso que determinan desde dónde se puede acceder a propiedades y métodos.

class CuentaBancaria {
    private saldo: number;
    protected numeroCuenta: string;
    public titular: string;
    
    constructor(titular: string, numeroCuenta: string) {
        this.titular = titular;
        this.numeroCuenta = numeroCuenta;
        this.saldo = 0;
    }
    
    public depositar(cantidad: number): void {
        if (cantidad > 0) {
            this.saldo += cantidad;
        }
    }
    
    public consultarSaldo(): number {
        return this.saldo;
    }
}

Herencia

La herencia permite crear nuevas clases basadas en clases existentes, reutilizando y extendiendo funcionalidad. La clase derivada hereda propiedades y métodos de la clase base, pudiendo añadir nuevas características o modificar comportamientos existentes.

class Empleado {
    protected nombre: string;
    protected salario: number;
    
    constructor(nombre: string, salario: number) {
        this.nombre = nombre;
        this.salario = salario;
    }
    
    trabajar(): void {
        console.log(`${this.nombre} está trabajando`);
    }
}

class Desarrollador extends Empleado {
    private lenguajes: string[];
    
    constructor(nombre: string, salario: number, lenguajes: string[]) {
        super(nombre, salario);
        this.lenguajes = lenguajes;
    }
    
    programar(): void {
        console.log(`${this.nombre} está programando en ${this.lenguajes.join(', ')}`);
    }
}

Polimorfismo

El polimorfismo permite que objetos de diferentes clases respondan de manera específica a la misma interfaz o método. Esto se logra mediante la sobrescritura de métodos en clases derivadas.

abstract class Animal {
    abstract hacerSonido(): void;
    
    dormir(): void {
        console.log("El animal está durmiendo");
    }
}

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

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

Características avanzadas de TypeScript

Interfaces y contratos

Las interfaces en TypeScript definen contratos que las clases deben cumplir, especificando qué propiedades y métodos deben implementar sin definir su implementación concreta.

interface Volador {
    volar(): void;
    altitudMaxima: number;
}

interface Nadador {
    nadar(): void;
    profundidadMaxima: number;
}

class Pato implements Volador, Nadador {
    altitudMaxima = 100;
    profundidadMaxima = 5;
    
    volar(): void {
        console.log("El pato está volando");
    }
    
    nadar(): void {
        console.log("El pato está nadando");
    }
}

Clases abstractas

Las clases abstractas proporcionan una base común para otras clases, combinando implementaciones concretas con métodos abstractos que deben ser implementados por las clases derivadas.

abstract class Forma {
    protected color: string;
    
    constructor(color: string) {
        this.color = color;
    }
    
    abstract calcularArea(): number;
    
    mostrarInfo(): void {
        console.log(`Forma de color ${this.color} con área ${this.calcularArea()}`);
    }
}

class Rectangulo extends Forma {
    private ancho: number;
    private alto: number;
    
    constructor(color: string, ancho: number, alto: number) {
        super(color);
        this.ancho = ancho;
        this.alto = alto;
    }
    
    calcularArea(): number {
        return this.ancho * this.alto;
    }
}

Propiedades y métodos estáticos

Los miembros estáticos pertenecen a la clase en sí misma, no a instancias específicas. Son útiles para funcionalidades que no requieren datos de instancia.

class Utilidades {
    static readonly PI = 3.14159;
    
    static calcularCircunferencia(radio: number): number {
        return 2 * this.PI * radio;
    }
    
    static generarId(): string {
        return Math.random().toString(36).substr(2, 9);
    }
}

// Uso sin crear instancia
const circunferencia = Utilidades.calcularCircunferencia(5);
const id = Utilidades.generarId();

Composición y agregación

Además de la herencia, TypeScript permite establecer relaciones entre objetos mediante composición y agregación, creando sistemas más flexibles y modulares.

class Motor {
    private potencia: number;
    
    constructor(potencia: number) {
        this.potencia = potencia;
    }
    
    encender(): void {
        console.log(`Motor de ${this.potencia}HP encendido`);
    }
}

class Automovil {
    private motor: Motor;
    private marca: string;
    
    constructor(marca: string, potenciaMotor: number) {
        this.marca = marca;
        this.motor = new Motor(potenciaMotor); // Composición
    }
    
    arrancar(): void {
        console.log(`Arrancando ${this.marca}`);
        this.motor.encender();
    }
}

La programación orientada a objetos en TypeScript ofrece herramientas robustas para crear arquitecturas de software bien estructuradas. La combinación de tipado estático, características avanzadas de POO y la flexibilidad de JavaScript proporciona un entorno ideal para desarrollar aplicaciones complejas y mantenibles.