Hasta ahora estamos estado "cuadriculando" todo para obtener algoritmos: tratábamos de convertir cualquier cosa en un procedimiento o una función que pudiéramos emplear en nuestros programas.
Pero no todo lo que nos rodea es tan fácil de cuadricular. Supongamos por ejemplo que tenemos que introducir datos sobre una puerta en nuestro programa. ¿Nos limitamos a programar los procedimientos AbrirPuerta y CerrarPuerta? Al menos, deberíamos ir a la zona de declaración de variables, y allí guardaríamos otras datos como su tamaño, color, etc.
No está mal, pero es antinatural. ¿A qué me refiero? Pues a que una puerta es un conjunto: no podemos separar su color de su tamaño, o de la forma en que debemos abrirla o cerrarla. Sus características son tanto las físicas (lo que hasta ahora llamábamos variables) como sus comportamientos en distintas circunstancias (lo que para nosotros eran los procedimientos). Todo ello va unido, formando un OBJETO.
Por otra parte, si tenemos que explicar a alguien lo que es el portón de un garaje, y ese alguien no lo ha visto nunca, pero conoce cómo es la puerta de su casa, le podemos decir "se parece a una puerta de una casa, pero es más grande para que quepan los coches, está hecha de metal en vez de madera..."
Finalmente, conviene recordar que "abrir" no se refiere sólo
a una puerta. También podemos hablar de abrir una ventana
o un libro, por ejemplo.
Pues con esta discusión filosófica ;-) hemos comentado casi sin saberlo las tres características más importantes de la Programación Orientada a Objetos (OOP):
Los objetos en Pascal se definen de forma parecida a los registros (record), sólo que ahora también incluirán procedimientos y funciones. Vamos a escribir un mensaje en una cierta posición de la pantalla. Este será nuestro objeto "título".
type
{ Def. tipo }
titulo = object
texto: string;
{ Variables }
x,y : byte;
procedure FijaCoords(nuevoX, nuevoY: byte);
{ Métodos }
procedure FijaTexto(mensaje: string);
procedure Escribe;
end;
var
miTitulo: titulo;
{ Variable de tipo objeto }
Accederemos a los métodos y a los datos precediendo el nombre de cada uno por el nombre de la variable y por un punto, como hacíamos con los registros (record):
miTitulo.x := 23;
miTitulo.y := 12;
miTitulo.FijaTexto('Hola');
miTitulo.Escribe;
Lo anterior se entiende, ¿verdad? Sin embargo, hay algo que se puede pero no se debe hacer: NO SE DEBE ACCEDER DIRECTAMENTE A LOS DATOS. Esto es otra de las máximas de la OOP (la ocultación de datos). Para modificarlos, lo haremos siempre a través de algún procedimiento (método) del objeto.
Por eso es por lo que hemos definido los procedimientos FijaCoords y FijaTexto... ¿¡definido!? ¡Pero si sólo está la primera línea!... }:-)
Don't panic! Esto no es nuevo para nosotros: cuando creábamos una unidad (unit), teníamos un encabezamiento (interface) en el que sólo poníamos las cabeceras de las funciones y procedimientos, y luego un desarrollo (implementation), donde realmente iba todo el código. ¿Verdad? Pues aquí ocurrirá algo parecido.
Vamos a ir completando el programa para que funcione, y así
irá quedando todo más claro:
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Primer ejemplo de }
{ Prog. Orientada Obj. }
{ OBJETOS1.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{--------------------------}
program Objetos1; { Nuestro primer programa en OOP }
uses crt; { Usaremos "GotoXY" }
type { Aquí definimos nuestro objeto }
titulo = object
texto: string; { El texto que se escribirá }
x,y : byte; { En qué posición }
procedure FijaCoords(nuevoX, nuevoY: byte); { Pues eso }
procedure FijaTexto(mensaje: string); { Idem }
procedure Escribe; { Lo escribe, claro }
end;
var
miTitulo: titulo; { Una variable de ese tipo }
procedure titulo.FijaCoords(nuevoX, nuevoY: byte);
begin { Definimos el procedimiento: }
x := nuevoX; { Actualiza las coordenadas }
y := nuevoY;
end;
procedure titulo.FijaTexto(mensaje: string);
begin { Actualiza el texto }
Texto := Mensaje;
end;
procedure titulo.Escribe;
begin { Muestra el título }
Gotoxy(X,Y);
Write(Texto);
end;
begin { -- Cuerpo del programa --}
ClrScr; { Que se vea qué hacemos }
miTitulo.FijaCoords(37,12);
miTitulo.FijaTexto('Hola');
miTitulo.Escribe;
end.
¿Y todo este rollazo de programa para escribir "Hola"? Nooooo.... Ya iremos viendo las ventajas, pero eso el próximo día, para que no resulte demasiado denso...