Laboratorio: Implementación de POO en TypeScript

Objetivo

Implementar conceptos de Programación Orientada a Objetos (POO) en una aplicación web utilizando TypeScript. Requisitos Previos

• Node.js y npm instalados

Paso 1: Instalación de TypeScript

• Inicializar un proyecto Node.js:

mkdir poo-typescript
cd poo-typescript
npm init -y

Con los comandos anteriores se crea un nuevo proyecto Node.js con un archivo package.json predeterminado.

Instalar TypeScript:

npm install typescript --save-dev

Con el comando anterior, se instala TypeScript como una dependencia de desarrollo en el proyecto.

Crear el archivo de configuración tsconfig.json:

npx tsc --init

Este comando crea un archivo tsconfig.json con la configuración predeterminada para TypeScript.

Estructura del Proyecto:

/poo-typescript
├── src
│   ├── encapsulamiento.ts
│   ├── herencia.ts
│   ├── polimorfismo.ts
│   └── main.ts
└── tsconfig.json

En la estructura del proyecto, src contendrá los archivos TypeScript con ejemplos de encapsulamiento, herencia y polimorfismo, y main.ts será el archivo principal para ejecutar los ejemplos.

Paso 2: Definición de Clases y Encapsulamiento

• Crear una clase Persona en src/encapsulamiento.ts:

• Agregar métodos para obtener y establecer propiedades privadas en Persona:

// src/encapsulamiento.ts

class Persona {
    private nombre: string;
    private edad: number;

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

    public getNombre(): string {
        return this.nombre;
    }

    public getEdad(): number {
        return this.edad;
    }

    public setNombre(nombre: string): void {
        this.nombre = nombre;
    }

    public setEdad(edad: number): void {
        this.edad = edad;
    }
}

export { Persona };

En el código anterior se define una clase Persona con propiedades privadas nombre y edad, y métodos para obtener y establecer los valores de estas propiedades.

Paso 3: Herencia

• Crear una clase Estudiante que herede de Persona en src/herencia.ts:

// src/herencia.ts

import { Persona } from './encapsulamiento';

class Estudiante extends Persona {
    private matricula: string;

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

    public getMatricula(): string {
        return this.matricula;
    }

    public setMatricula(matricula: string): void {
        this.matricula = matricula;
    }
}

export { Estudiante };

En el código anterior se define una clase Estudiante que hereda de Persona y agrega una propiedad matricula con métodos para obtener y establecer su valor.

Paso 4: Polimorfismo

• Crear una clase Profesor y una función para demostrar polimorfismo en src/polimorfismo.ts:

// src/polimorfismo.ts

import { Persona } from './encapsulamiento';

class Profesor extends Persona {
    private materia: string;

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

    public getMateria(): string {
        return this.materia;
    }

    public setMateria(materia: string): void {
        this.materia = materia;
    }

    public presentar(): string {
        return `Soy el profesor ${this.getNombre()} y enseño ${this.materia}.`;
    }
}

class Estudiante extends Persona {
    private matricula: string;

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

    public getMatricula(): string {
        return this.matricula;
    }

    public setMatricula(matricula: string): void {
        this.matricula = matricula;
    }

    public presentar(): string {
        return `Soy el estudiante ${this.getNombre()} y mi matrícula es ${this.matricula}.`;
    }
}

function presentarPersona(persona: Persona): string {
    if (persona instanceof Profesor) {
        return persona.presentar();
    } else if (persona instanceof Estudiante) {
        return persona.presentar();
    } else {
        return `Soy ${persona.getNombre()} y tengo ${persona.getEdad()} años.`;
    }
}

export { Profesor, Estudiante, presentarPersona };

En el código anterior se define una clase Profesor que hereda de Persona y agrega una propiedad materia con métodos para obtener y establecer su valor, y un método presentar para mostrar información específica del profesor. También se define una función presentarPersona que demuestra polimorfismo al presentar a una persona como profesor, estudiante o persona genérica.

Paso 5: Implementación en el Archivo Principal

• Crear el archivo principal src/main.ts para ejecutar ejemplos:

// src/main.ts

import { Persona } from './encapsulamiento';
import { Estudiante } from './herencia';
import { Profesor, presentarPersona } from './polimorfismo';

const persona = new Persona('Carlos', 30);
console.log(`Persona: ${persona.getNombre()}, ${persona.getEdad()} años`);

const estudiante = new Estudiante('Ana', 22, '2022001');
console.log(`Estudiante: ${estudiante.getNombre()}, ${estudiante.getEdad()} años, Matrícula: ${estudiante.getMatricula()}`);

const profesor = new Profesor('Luis', 40, 'Matemáticas');
console.log(`Profesor: ${profesor.getNombre()}, ${profesor.getEdad()} años, Materia: ${profesor.getMateria()}`);

console.log(presentarPersona(persona));
console.log(presentarPersona(estudiante));
console.log(presentarPersona(profesor));

En el código anterior se crean instancias de Persona, Estudiante y Profesor, y se muestra información sobre cada uno de ellos. También se llama a la función presentarPersona para mostrar información polimórfica sobre las personas.

Paso 6: Compilar y Ejecutar

• Compilar el proyecto:

npx tsc

Ejecutar el archivo JavaScript generado:

node src/main.js

Conclusiones

En este laboratorio, se ha implementado la Programación Orientada a Objetos (POO) en una aplicación web utilizando TypeScript. Se han definido clases con propiedades y métodos, se ha demostrado el encapsulamiento, la herencia y el polimorfismo, y se ha ejecutado un ejemplo para mostrar el funcionamiento de estos conceptos en TypeScript.

Reto

Extiende la aplicación con más clases y métodos que demuestren otros conceptos de POO, como abstracción, interfaces, métodos estáticos, etc.