Turbo Pascal 7 – Capítulo 07 – Programación orientada a objetos

La Programación Orientada a Objetos (POO) es un paradigma que organiza el código en torno a objetos y sus interacciones. Turbo Pascal 7, aunque es un lenguaje principalmente procedural, permite implementar conceptos básicos de POO, lo que mejora la modularidad y reutilización del código.

Conceptos Fundamentales de la POO

• Clase: Un plano o plantilla que define la estructura y el comportamiento de un objeto.
• Objeto: Una instancia concreta de una clase, que puede tener sus propias propiedades y métodos.
• Encapsulación: Oculta los detalles internos de una clase, exponiendo solo lo necesario para su uso.
• Herencia: Permite crear nuevas clases basadas en clases existentes, heredando sus atributos y comportamientos.
• Polimorfismo: Capacidad de distintos objetos de responder a un mismo método de manera específica.

Clases y Objetos en Turbo Pascal 7

Aunque Turbo Pascal 7 no es un lenguaje orientado a objetos puro, puede simular algunos aspectos. Ejemplo de declaración de clase y creación de objeto:

type
  TPersona = class
  private
    nombre: string;
    edad: Integer;
  public
    constructor Crear(n: string; e: Integer);
    procedure MostrarInfo;
  end;

constructor TPersona.Crear(n: string; e: Integer);
begin
  nombre := n;
  edad := e;
end;

procedure TPersona.MostrarInfo;
begin
  writeln('Nombre: ', nombre);
  writeln('Edad: ', edad);
end;

var
  persona1: TPersona;

begin
  persona1 := TPersona.Crear('Juan', 25);
  persona1.MostrarInfo;
end.

Encapsulación, Herencia y Polimorfismo

Encapsulación:

En Turbo Pascal 7, la encapsulación se logra mediante las secciones private y public. Los miembros privados son inaccesibles desde fuera de la clase.

Herencia:

Puedes lograr la herencia de propiedades y métodos a través de tipos de datos estructurados. Por ejemplo, puedes usar registros como «clases base» y agregar más atributos en «clases derivadas».

Polimorfismo:

No se logra de manera tan fluida como en lenguajes de programación modernos, pero puedes simularlo con el uso de tipos de datos genéricos y procedimientos que trabajan con esos tipos.

Ejercicios Resueltos

Ejercicio 1: Creación de una Clase

Crea una clase Rectangulo que tenga atributos para la base y altura, y métodos para calcular el área y el perímetro.

type
  TRectangulo = record
    base, altura: Real;
  end;

function CalcularArea(rect: TRectangulo): Real;
begin
  CalcularArea := rect.base * rect.altura;
end;

function CalcularPerimetro(rect: TRectangulo): Real;
begin
  CalcularPerimetro := 2 * (rect.base + rect.altura);
end;

var
  miRectangulo: TRectangulo;

begin
  miRectangulo.base := 5;
  miRectangulo.altura := 3;

  writeln('Área del rectángulo: ', CalcularArea(miRectangulo));
  writeln('Perímetro del rectángulo: ', CalcularPerimetro(miRectangulo));
end.

Ejercicio 2: Herencia y Polimorfismo

Crea una «clase base» llamada Vehiculo con atributos básicos, y dos «clases derivadas» Auto y Camion con atributos específicos.

type
  TVehiculo = record
    marca, modelo: string;
    ano: Integer;
  end;

type
  TAuto = record
    vehiculo: TVehiculo;
    pasajeros: Integer;
  end;

type
  TCamion = record
    vehiculo: TVehiculo;
    capacidadCarga: Real;
  end;

var
  miAuto: TAuto;
  miCamion: TCamion;

begin
  miAuto.vehiculo.marca := 'Toyota';
  miAuto.vehiculo.modelo := 'Corolla';
  miAuto.vehiculo.ano := 2020;
  miAuto.pasajeros := 5;

  miCamion.vehiculo.marca := 'Ford';
  miCamion.vehiculo.modelo := 'F-150';
  miCamion.vehiculo.ano := 2018;
  miCamion.capacidadCarga := 1500;

  writeln('Auto - Marca: ', miAuto.vehiculo.marca);
  writeln('Camión - Capacidad de carga: ', miCamion.capacidadCarga);
end.

Conclusiones

Aunque Turbo Pascal 7 no es un lenguaje de programación orientado a objetos completo, es posible aplicar conceptos básicos de POO a través de registros y procedimientos. Los ejercicios resueltos en este capítulo demuestran cómo crear clases, implementar herencia y simular polimorfismo en este entorno. A medida que te familiarices con estos conceptos, podrás crear programas más estructurados y reutilizables, aprovechando los beneficios de la Programación Orientada a Objetos.