PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

PROGRAMACIÓN ORIENTADA A OBJETOS (POO).

En Pascal, los Objetos son perecidos a los registros, con la diferencia de que los Objetos además de incluir datos, incluyen rutinas para la manipulación de dichos datos.
Para trabajar con objetos deberíamos comenzar diseñando las diversas estructuras entresacando de todas ellas las características comunes e implementando un tipo objeto genérico del cual descendieran los demás.

Declaración de objetos :
Type
Nombre=OBJECT
dato1 :tipo1 ;
dato2 :tipo2 ;
procedure procedimiento1 ;
Procedure procedimiento2[(parámetros)] :
end ;

Dentor del tipo, se incluyen cabeceras de procedimientos y funciones. La implementación de estos procedimientos y funciones dentro del objeto se efectúa de forma independiente, y a estos procedimientos y funciones dentro del objeto se les denomina Métodos.

Declaración de métodos :

Procedure Nombre.procedimiento1 ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Procedure Nombre.procedimiento2[(lista parámetros formales)] ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Los datos de un objeto son siempre accesibles para los métodos a pesar de que estén declarados en lugares diferentes (de forma independiente) .Ejemplo :

Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;

Procedure Persona.Inicializar(n :string ;de :integer ;d :string) ;
Begin
nombre :=n ;
edad := ed ;
domicilio :=d ;
End ;

{Para trabajar con objetos, necesitamos variables de tipo objeto llamadas Instancias del objeto.}
{A los diferentes tipos se les denomina Clases}

Var
p :Persona ;
n,d :string :
ed :integer ;

BEGIN
WriteLn(‘Nombre :’) ;
ReadLn(n) ;
WriteLn( ‘Edad :’) ;
ReadLn(ed) ;
WriteLn(‘Domicilio :’) ;
ReadLn(d) ;
p.inicializar(n,ed,d) ;
END.

Los objetos pueden heredar campos y métodos de otros objetos. Cuando esto sucede lo declararemos de la siguiente manera :

Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;

Alumno=OBJECT (Persona) { Hereda Persona}
nota :real ;
Procedure Inicializar(n :string ; ed :integer ; d :string ; no :real) ;
end ;

Procedure Persona.Inicializar.....
Begin
...............
End ;

Procedure Alumno.Inicialzar(n :string ; ed :integer ; d :string ; no :real) ;
Begin
nombre :=n ;
edad :=ed ;
domicilio :=d ;
nota :=no ;
End ;

Var a :Alumno ;

El objeto descendiente hereda los campos y métodos del objeto padre, y puede tener más campos y métodos nuevos y también puede redefinirlos.

Todos los métodos vistos hasta ahora eran ESTÁTICOS (las referencias se resuelven en tiempo de compilación), pero los métodos también pueden ser VIRTUALES (las referencias se resuelven en tiempo de ejecución). Cuando el compilador detecta la compilación de un método virtual, crea una Tabla de Métodos Virtuales. Las instancias (variables) declaradas de un tipo objeto con métodos virtuales (tipo método virtual), necesitan inicializarse a través de unCONSTRUCTOR, que enlaza la instancia con la Tabla de Métodos Virtuales.
Para eliminar la conexión se emplean DESTRUCTORES (sólo cuando se trabaja con estructuras dinámicas(punteros)), necesarios siempre que usamos métodos virtuales.
Para que un método sea un constructor, habrá que sustituir la palabra ‘procedure’ por ‘constructor’.
Para que un método sea un destructor, habrá que sustituir la palabra ‘procedure’ por ‘destructor’.
Un método es virtual cuando su cabecera acaba en ‘virtual ;’.
Los métodos virtuales son el instrumento adecuado para el POLIMORFISMO. Un método es polimórfico cuando se ejecuta de diferente forma segús el objeto desde el cual se le llame.

CARACTERÍSTICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS.

• Encapsulación.
• Herencia.
• Polimorfismo.

La Encapsulación consiste en que los objetos agrupan tanto los datos como los procedimientos necesarios para su manipulación. No se debe acceder a los datos de un objeto directamente, sino que siempre se debe hacer a través de los métodos correspondientes. (Ejemplo : En lugar de referenciar area, referenciaríamos figura.area, siendo figura el objeto).
Cuando trabajamos con unidades es posible declarar tipos de objeto en dichas unidades. Si se desea que el usuario de una unidad (que use objetos) no pueda acceder a los campos o a determinados métodos del objeto, habrá que declararlos como privados, para lo cual la declaración de objeto se hará en la sección de Interface, pero los métodos tendrán que ser implementados en la sección de Implementation.Ejemplo :

Unit ; {De 8 caracteres máximo}

INTERFACE
Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
Procedure Inicializar(n :string ; de :integer ; d :string) ;
end ;
Alumno=OBJECT (Persona)
nota :real ;
procedure Inicializar(n :string ; de :integer ; d :string ;no :real) ;
end ;
IMPLEMENTATION
Procedure persona.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Procedure alumno.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Para declarar las partes privadas :

1. Declaramos las partes PUBLICAS : 1º datos y luego métodos.
2. Declaramos las partes PRIVADAS poniendo ántes ‘PRIVATE’ :1º datos y luego métodos.
Ejemplo :
Type Persona=OBJECT
domicilio :string ; {Partes}
procedure Inicializar (--------------------------) ; {Públicas}
PRIVATE
nombre :string ; {Partes}
edad ;integer ; {Privadas}
end ;

En un tipo objeto la declaración de los métodos debe ir después de los datos (excepto cuandoy parte privada).
Es posible utilizar punteros con los objetos de la forma habitual :
Type
puntero=^Persona ;
Persona=OBJECT
------------- ;
------------- ;
end ;
Variable
p :puntero ;
Begin
New(p) ;
p^.Inicializar(‘Pedro’,5,’Goya’) ;
------------------- ;
------------------- ;
------------------- ;
Dispose(p) ;
end ;


Type
figura=OBJECT
nombre :string ;
area :real ;
perimetro :real ;
Constructor Inicializar ;{Para llamar a virtuales}
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
Procedure Visualizar ;
end ;
Rectangulo=OBJECT (figura)
base :real ;
altura :real ;
{Si se redefine virtual se amntiene la cabecera}
Constructor Inicializar(d,a :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Circulo=OBJECT (figura)
radio :real ;
Constructor Inicializar(r :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Constructor figura.Inicializar ;
Begin
WriteLn(‘Indique la figura :’) ;
ReadLn(nombre) ;
End ;
Procedure figura.CalcularArea ;
Begin
area :=0 ;
End ;

Procedure figura.CalcularPerimetro ;
Begin
perimetro :=0 ;
End ;

Procedure figura.Visualizar ;
Begin
CalcularArea ;
CalcularPerimetro ;
WriteLn(‘La figura es’,nombre) ;
WriteLn(‘El area es’,area) ;
WriteLn(‘El perimetro es’,perimetro) ;
end ;

Constructor Rectangulo.Inicializar(b,a :real) ;
Begin
base :=b ;
altura :=a ;
nombre :=’Rectangulo’ ;
End ;

Procedure Rectangulo.CalcularArea ;
Begin
area :=base*altura ;
End ;

Procedure Rectangulo.CalcularPerimetro ;
Begin
perimetro:=2*(base+altura) ;
End ;

Constructor Circulo.Inicializar(r:real) ;
Begin
radio :=r ;
nombre :=’Circulo’ ;
End ;

Procedure Circulo.CalcularArea ;
Begin
area :=3.141592*radio*radio;
End ;

Procedure Circulo.CalcularPerimetro ;
Begin
perimetro:=2*3.141592*radio;
End ;

Var
f :figura ;
c :Circulo ;
rec :Rectangulo ;
a,b :real ;
r :real ;

Begin
WriteLn(‘Deme Radio’) ;
ReadLn(r) ;
c.Inicializar(r) ;
c.Visualizar ; {Es polimórfico:se comporta de una manera o de otra según desde donde se le llame
Sin virtual, nos pasa en Visualizar 0,0 (lo que había en compilación).Con virtual pasa lo que hay en ejecución).}
WriteLn(‘Deme Base y Altura :’) ;
ReadLn(b,a) ;
rec.Inicializar(r) ;
rec.visualizar ;





Con punteros :

Type
rt=^Rectangulo ;
cr=^Circulo ;
Var
c :cr ;
rec :rt ;
a,b,r :real ;
Begin
WriteLn....... ;
ReadLn(r) ;
New(c) ;
c^.Inicializar(r) ;
c^.Visualizar ;
WriteLn........ ;
New(rec) ;
rec^.Inicializar(b,a) ;
rec^.Visualizar ;