Curso de Pascal. Tema 16: Programación Orientada
a Objetos.
Antes de empezar, un consejo: si la Programación Orientada a Objetos
es nueva para ti, lee todo este texto seguido: Si algo no
lo entiendes en un principio, es muy fácil que algún párrafo
posterior te lo aclare... espero... O
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):
-
ENCAPSULACION: No podemos separar los comportamientos de las
características de un objeto. Los comportamientos serán
procedimientos o funciones, que en OOP llamaremos METODOS. Las características
serán variables, como las que hemos usado siempre. La apariencia
de un objeto en Pascal, como veremos un poco más adelante, recordará
a un registro o "record".
-
HERENCIA: Unos objetos pueden heredar métodos y datos de
otros. Esto hace más fácil definir objetos nuevos a
partir de otros que ya teníamos anteriormente (como ocurría
con el portón y la puerta) y facilitará la reescritura de
los programas, pudiendo aprovechar buena parte de los anteriores... si
están bien diseñados.
-
POLIMORFISMO: Un mismo nombre de un método puede hacer referencia
a comportamientos distintos (como abrir una puerta o un libro). Igual
ocurre para los datos: el peso de una puerta y el de un portón los
podemos llamar de igual forma, pero obviamente no valdrán lo mismo.
Comentado esto, vamos a empezar a ver ejemplos en Pascal para tratar de
fijar conceptos. Para todo lo que viene a continuación, será
necesario emplear la versión 5.5 o superior de Turbo Pascal.
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:
}
{ - 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...
| 