Polimorfismo en Delphi5
 

Hola de nuevo amigos ¡

Estoy intentando crearme una unidad, la cual se basa en una jerarquia de clases, hasta tercer nivel(clases nietas). Para crear los procedimientos que me muestren los datos tengo que usar el polimorfismo. Segun e estado leiendo, todos los procedimientos Mostrar los debo hacer con el mismo numero de parametros, yo e imaginado que una de una clase nieta a otra no debere de ponerle sus variables propias,sin embargo todas las clases padre si deberan de llebar todas las variables de sus hijas (la clase padre de todas me sale con chorro de parametros que no veas). En fin, como podreis observar el polimorfismo no lo tengo nada claro, la cuestion es, partiendo de la base que lo que llebo es correcto, la funcion padre de todas la tendre que declarar virtual y en todas las hijas le tendre que poner Override?? y siendo asi, si una clase ademas de ser hija, es padre a su vez de otras, tendria que ponerle el override y el virtual??

Espero haberme explicado con claridad y gracias por adelantado de nuevo ¡ Salu2

¿Para qué quieres meter todo en parámetros? Declara el método Mostrar con un mínimo de parámetros entendibles para la clase raíz y todos sus descendientes. Cuando trabajes con un objeto de una clase descendiente, lo construyes, asignas valores a sus propiedades (incluidas las de las clases que le antecedan) y luego llamas al método Mostrar.

En resumen: usa propiedades para pasar información a las clases en lugar de tratar de hacerlo através de parámetros de una función.

// Saludos

polimorfismo
 

Siento mi ignorancia,pero no e entendido bien eso.

De lo que se trata el problema que tengo que hacer es que yo almaceno los objetos en un Array polimorfico, luego tengo que mostrar esos datos. Lo de los parametros "entendibles", a que te refieres?

Así es. Suponte que tienes un arreglo:

Código Delphi [-]
Objetos: array[1..N] of TObjetoPadre;

Si TObjetoPadre tiene un método virtual Mostrar(...), puedes recorrer polimórficamente el arreglo:

Código Delphi [-]
for I := 1 to N do
  Objetos[i].Mostrar(???);

sin importar si algunos de los objetos son de clases descendientes de TObjetoPadre. El polimorfismo consiste en que se escoge el método adecuado dependiendo de la clase real del objeto.

Pero Mostrar no puede cambiar de parámetros en los descendientes porque entonces, ¿cuáles de ellos especificarías en el código de arriba?

Pero los parámetros de un método (como de cualquier procedimiento) sirven para pasar información.

Suponte que originalmente querías algo como:

Código Delphi [-]
procedure TObjetoPadre.Mostrar(P1, P2);
procedure TObjetoHijo.Mostrar(P1, P2, H1);
procedure TObjetoNieto.Mostrar(P1, P2, H1, N1, N2, N3);

Es decir, los parámetros P son válidos para TObjetoPadre y todos sus descendientes, los parámetros H son válidos para TObjetoHijo y todos sus descendiente y los parámetros N son válidos para TObjetoNieto y todos sus descendientes.

Entonces convierte esos parámetros en propiedades de tus objetos y no pongas parámetros en Mostrar o sólo los de la clase raíz:

Código Delphi [-]
TObjetoPadre = class
  property P1;
  property P2;

  procedure Mostrar; virtual;
end;

TObjetoHijo = class(TObjetoPadre)
  property H1;

  procedure Mostrar; override;
end;

TObjetoNieto = class(TObjetoHijo)
  property N1;
  property N2;
  property N3;

  procedure Mostrar; override;
end;

Habría que ver cómo llenas el arreglo pero en algún momento tienes que construir los objetos que le pones. Apenas los construyas, les asignas valores a sus propiedades específicas según la clase que se use:

Código Delphi [-]
var
  H: TObjetoHijo;

begin
  H := TObjetoHijo.Create;

  H.P1 := ValorDeP1;
  H.P2 := ValorDeP2;
  H.H1 := ValorDeH1;

  Objetos[i] := H;
end;

Entonces, el método Mostrar específico de cada clase usara las propiedades como antes usaba los parámetros. Pero ahora Mostar ya no tiene parámetros, es homogéneo para toda la jerarquía de clases y puedes llamarlo polimórficamente sin problemas:

Código Delphi [-]
for I := 1 to N do
  Objetos[i].Mostrar;

// Saludos

Si lees esto, muchas gracias por la informacion.

Ahora mismo no tngo tiempo para ponerme con esto(me voy al trabajo), lo hare luego a la noche, parece ser que todo el trabajo que e hecho durante estos ultimos 2 dias no vale de nada. El razonamiento que deduje fue que, haciendolo con parametros, todos los procedimientos de todas las clases hijas, nietas, le estaba pasando todos los mismos parametros, luego, dentro de cada procediemiento escogia los que necesitaba y los asignaba a una variable.

Código Delphi [-]
 TBiblioteca=class //Clase padre
   private
     Editorial:string;
     Dir_Edit:string;
     Per_Contac:string;
     Tlfno:string[9];
     Poblacion:string[15];
     Provincia:string[15];
   public
     constructor Inicia;
     destructor Destroy;
     procedure Alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov:string);
     procedure Baja;
     procedure Modificacion;
     procedure Mostrar(Edit,Dir_Editorial,Persona_contact,telefono,Poblac,Prov,Nom,Dir,
                       aut,nom_nov,tisbn,epk,per_prin,tem,pers:string;
                       tip:tipo;
                       ano_publ:integer;
                       autobio:boolean);virtual;
   end;
  
   TNovela=class(TBiblioteca)//Clase que hereda de Biblioteca
   private
     Autor:string;
     Año_Public:Integer;
     Nombre_Nov:string;
     ISBN:string;
   public
     constructor Inicia;
     destructor Destroy;
     procedure alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;
                    ano_publ:integer);
     procedure Mostrar(Edit,Dir_Editorial,Persona_contact,telefono,Poblac,Prov,Nom,Dir,
                       aut,nom_nov,tisbn,epk,per_prin,tem,pers:string;
                       tip:tipo;
                       ano_publ:integer;
                       autobio:boolean);override;
   end;
  
 TPrensa=class(TBiblioteca) //Clase que hereda de Biblioteca
   private
     Nombre:string;
     Director:string;
     Ttipo:Tipo;
   public
     constructor Inicia;
     destructor Destroy;
     procedure alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,nom,dir:string; tip:tipo);
     procedure Mostrar(Edit,Dir_Editorial,Persona_contact,telefono,Poblac,Prov,Nom,Dir,
                       aut,nom_nov,tisbn,epk,per_prin,tem,pers:string;
                       tip:tipo;
                       ano_publ:integer;
                       autobio:boolean);override;
   end;
  
 
   Tficcion=class(Tnovela) //Clase que hereda de Novela
   private
     Tema:string;
   public
     constructor Inicia;
     destructor Destroy;
     procedure alta(tem,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,
  Prov,aut,nom_nov,tisbn:string;ano_publ:integer);
     procedure Mostrar(Edit,Dir_Editorial,Persona_contact,telefono,Poblac,Prov,Nom,Dir,
                       aut,nom_nov,tisbn,epk,per_prin,tem,pers:string;
                       tip:tipo;
                       ano_publ:integer;
                       autobio:boolean);override;
   end;
  
  
   Tbiografia=class(Tnovela)  //Clase que hereda de Novela
   private
     Personaje:string;
     Autobiografia:boolean;
   public
     constructor Inicia;
     destructor Destroy;
     procedure alta(Pers,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,
  Prov,aut,nom_nov,tisbn:string;ano_publ:integer;Autobio:boolean);
     procedure Mostrar(Edit,Dir_Editorial,Persona_contact,telefono,Poblac,Prov,Nom,Dir,
                       aut,nom_nov,tisbn,epk,per_prin,tem,pers:string;
                       tip:tipo;
                       ano_publ:integer;
                       autobio:boolean);override;
   end;

No se si me explico con claridad, la cuestion es que no me funcionaba, lo unico que funcionaba bien eran los parametros de las clases nietas(los propios), esto si lo visualiza bien, lo demas, solo visualiza el ultimo registro que se haya introducido.Creo que estoy al borde de una depresion con esto....En fin, otra vez mas gracias por esta informacion, ya que difiere de lo poco que me han explicado en clase(no me mencionaron lo de las propiedades, nos dijo el que me da clase que se hace con parametros). Cuando puedas, me gustaria que me dijeses, si este que me da clase me dijo que hay que hacerlo con parametros¿Puedo coger y decirle que no tiene ni idea de Polimorfismo??Salu2

Problema resuelto
 

Hola Roman ¡
Por fin e resuelto el problema, tenia una gran confusion, entre funciones que devuelven un valor, y funciones a las que les paso algun valor (gran problema de base). Al final lo e terminado haciendo con parametros, como me dijeron en clase. E comentado en clase lo de las propiedades, y segun me han dicho, las propiedades se usan mas bien para los objetos visuales. Muchas gracias por todas las molestias ocasionadas. Salu2

Pues no, las propiedades también se usan en objetos "no visuales", como bien te explicó Román.

Es más, en Delphi muchas de las clases son "no visuales" (lease TStringsList, TList, TObjectList, etc) y tienen varias propiedades.

Por lo que puede que la persona que te esté dando clases esté algo confundido (esto es por no pensar mal en esa persona... jejeje :p) en cuanto a las propiedades.



Saludos...

Pues a mi me gustaría ver como es que finalmente lo resolviste pues quiero ver en qué parte entra el polimorfismo. Y mira, yo no pretendo, realmente no lo pretendo porque no lo soy, un experto en POO, pero afirmaciones como "las propiedades se usan mas bien para los objetos visuales" carecen realmente de sentido así que toma con reserva lo que ahí te digan.

// Saludos

Hola Roman ¡
Te paso la Unit Biblioteca y le hechas un ojo

Código Delphi [-]
unit Ubiblioteca;
interface
type
  Tipo=(Economia,Deportes,General);//Tipo enunmerado
  TBiblioteca=class //Clase padre
  private
    Editorial:string;
    Dir_Edit:string;
    Per_Contac:string;
    Tlfno:string;
    Poblacion:string[15];
    Provincia:string[15];
  public
    constructor Inicia;
    destructor Destroy;
    procedure Alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov:string);
    procedure Baja;
    procedure Modificacion;
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); virtual;
  end;
  TNovela=class(TBiblioteca)//Clase que hereda de Biblioteca
  private
    Autor:string;
    Ano_Public:Integer;
    Nombre_Nov:string;
    ISBN:string;
  public
    constructor Inicia;
    destructor Destroy;
    procedure alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;ano_publ:integ  er);
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); override;
  end;
  TPrensa=class(TBiblioteca) //Clase que hereda de Biblioteca
  private
    Nombre:string;
    Director:string;
    Ttipo:Tipo;
  public
    constructor Inicia;
    destructor Destroy;
    procedure alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,nom,dir:string; tip:tipo);
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); override;
end;
  Thistorica=class(Tnovela)   //Clase que hereda de Novela
  private
    Epoca:string;
    Persona_prin:string;
  public
    constructor Inicia;
    destructor Destroy;
    procedure alta(Epk,per_prin,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;a  no_publ:integer);
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); override;
  end;
  Tficcion=class(Tnovela) //Clase que hereda de Novela
  private
    Tema:string;
  public
    constructor Inicia;
    destructor Destroy;
    procedure alta(tem,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;ano_publ:i  nteger);
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); override;
  end;
  Tbiografia=class(Tnovela)  //Clase que hereda de Novela
  private
    Personaje:string;
    Autobiografia:boolean;
  public
    constructor Inicia;
    destructor Destroy;
    procedure alta(Pers,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;ano_publ:  integer;Autobio:boolean);
    procedure mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); override;
  end;
implementation
  constructor Tbiblioteca.Inicia; //iniciamos la clase padre
  begin
    inherited create;
  end;
  procedure Tbiblioteca.Alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov:string);
  begin
    Editorial:=Edit;      //cargamos las variables con los valores que le pasamos
    Dir_Edit:=Dir_Editorial;
    Per_Contac:=Persona_Contact;
    Tlfno:=telefono;
    Poblacion:=Poblac;
    Provincia:=Prov;
  end;
  procedure Tbiblioteca.Baja;        //procedimiento baja
  begin
  end;
  procedure Tbiblioteca.Modificacion;    //procedimiento para modificar
  begin
  end;
  procedure Tbiblioteca.mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean); //procedimiento para mostrar
  begin
      Editorial1:=Editorial;      //cargamos las variables con los valores que le pasamos
      Dir_edit1:=Dir_Edit;
      Per_contac1:=Per_Contac;
      tlfno1:=Tlfno;
      Poblacion1:=Poblacion;
      provincia1:=Provincia;
  end;
  destructor Tbiblioteca.Destroy;  //destruimos la clase padre Tbiblioteca
  begin
    inherited destroy;
  end;

  constructor Tprensa.Inicia;  //iniciamos la clase hijja Tprensa
  begin
    inherited create;
  end;
  procedure Tprensa.alta(Edit,Dir_Editorial,Persona_Contact,Telefono,
                         Poblac,Prov,nom,dir:string; tip:tipo);
  begin
    inherited alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov);  //llamamos a la clase padre y le pasamos los valores en cuestion
    Nombre:=nom;
    Director:=dir;
    ttipo:=tip;
  end;
  procedure tprensa.mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean);
  begin
    inherited mostrar(Editorial1,Dir_Edit1,Per_Contac1,Tlfno1,
                                   Poblacion1,Provincia1,Autor1,Ano_Public1,
                                   Nombre_Nov1,ISBN1,Nombre1,Director1,
                                   Ttipo1,Epoca1,Persona_prin1,Tema1,Personaje1,
                                   Autobiografia1);
    nombre1:=nombre;
    director1:=director;
    ttipo1:=ttipo;
  end;
 
    destructor Tprensa.Destroy;  //destruimnos la clase hija tprensa
  begin
    inherited destroy;
  end;
  constructor Tnovela.Inicia; //iniciamos la clase hija Tnovela
  begin
    inherited create;
  end;
  procedure Tnovela.alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;ano_pu  bl:integer);
  begin
    inherited alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov);  //volvemos a llamar al procedmiento del padre "alta" y le pasamos los valores en cuestion
    Autor:=aut;
    Nombre_nov:=nom_nov;
    ISBN:=tisbn;
    ano_public:=ano_publ;
  end;
  procedure tnovela.mostrar(var Editorial1:string;
                      var Dir_Edit1:string;
                      var Per_Contac1:string;
                      var Tlfno1:string;
                      var Poblacion1:string;
                      var Provincia1:string;
                      var Autor1:string;
                      var Ano_Public1:Integer;
                      var Nombre_Nov1:string;
                      var ISBN1:string;
                      var Nombre1:string;
                      var Director1:string;
                      var Ttipo1:Tipo;
                      var Epoca1:string;
                      var Persona_prin1:string;
                      var Tema1:string;
                      var Personaje1:string;
                      var Autobiografia1:boolean);
   begin
    inherited mostrar(Editorial1,Dir_Edit1,Per_Contac1,Tlfno1,
                                   Poblacion1,Provincia1,Autor1,Ano_Public1,
                                   Nombre_Nov1,ISBN1,Nombre1,Director1,
                                   Ttipo1,Epoca1,Persona_prin1,Tema1,Personaje1,
                                   Autobiografia1);
    Ano_Public1:=ano_public;
    autor1:=autor;
    nombre_nov1:=nombre_nov;
    isbn1:=isbn;
   end;

  destructor Tnovela.Destroy;     //destruimos la clase hija Tnovela
  begin
    inherited destroy;
  end;
  constructor Thistorica.Inicia;
  begin
    inherited create;   //iniciamos la clase nieta Thistorica
  end;
  procedure Thistorica.alta(Epk,per_prin,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tis  bn:string;ano_publ:integer);
  begin
    inherited alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn,ano_publ);
    Epoca:=Epk;
    Persona_prin:=per_prin;
  end;
  procedure thistorica.mostrar(var Editorial1:string;
                            var Dir_Edit1:string;
                            var Per_Contac1:string;
                            var Tlfno1:string;
                            var Poblacion1:string;
                            var Provincia1:string;
                            var Autor1:string;
                            var Ano_Public1:Integer;
                            var Nombre_Nov1:string;
                            var ISBN1:string;
                            var Nombre1:string;
                            var Director1:string;
                            var Ttipo1:Tipo;
                            var Epoca1:string;
                            var Persona_prin1:string;
                            var Tema1:string;
                            var Personaje1:string;
                            var Autobiografia1:boolean);
  begin
  inherited mostrar(Editorial1,Dir_Edit1,Per_Contac1,Tlfno1,
                                   Poblacion1,Provincia1,Autor1,Ano_Public1,
                                   Nombre_Nov1,ISBN1,Nombre1,Director1,
                                   Ttipo1,Epoca1,Persona_prin1,Tema1,Personaje1,
                                   Autobiografia1);
  Epoca1:=Epoca;
  persona_prin1:=persona_prin;
  end;
  destructor Thistorica.Destroy;
  begin
    inherited destroy;
  end;
  constructor Tficcion.Inicia;
  begin
    inherited create;
  end;
  procedure Tficcion.alta(tem,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:string;a  no_publ:integer);
  begin
    inherited alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn,ano_publ);
    tema:=tem;
  end;
  procedure tficcion.mostrar(var Editorial1:string;
                            var Dir_Edit1:string;
                            var Per_Contac1:string;
                            var Tlfno1:string;
                            var Poblacion1:string;
                            var Provincia1:string;
                            var Autor1:string;
                            var Ano_Public1:Integer;
                            var Nombre_Nov1:string;
                            var ISBN1:string;
                            var Nombre1:string;
                            var Director1:string;
                            var Ttipo1:Tipo;
                            var Epoca1:string;
                            var Persona_prin1:string;
                            var Tema1:string;
                            var Personaje1:string;
                            var Autobiografia1:boolean);
  begin
  inherited mostrar(Editorial1,Dir_Edit1,Per_Contac1,Tlfno1,
                                   Poblacion1,Provincia1,Autor1,Ano_Public1,
                                   Nombre_Nov1,ISBN1,Nombre1,Director1,
                                   Ttipo1,Epoca1,Persona_prin1,Tema1,Personaje1,
                                   Autobiografia1);
  tema1:=tema;
  end;
  destructor Tficcion.Destroy;
  begin
    inherited destroy;
  end;
  constructor Tbiografia.Inicia;
  begin
    inherited create;
  end;
  procedure Tbiografia.alta(Pers,Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn:strin  g;ano_publ:integer;Autobio:boolean);
  begin
    inherited alta(Edit,Dir_Editorial,Persona_Contact,Telefono,Poblac,Prov,aut,nom_nov,tisbn,ano_publ);
    Personaje:=Pers;
    Autobiografia:=Autobio;
  end;
  procedure tbiografia.mostrar(var Editorial1:string;
                            var Dir_Edit1:string;
                            var Per_Contac1:string;
                            var Tlfno1:string;
                            var Poblacion1:string;
                            var Provincia1:string;
                            var Autor1:string;
                            var Ano_Public1:Integer;
                            var Nombre_Nov1:string;
                            var ISBN1:string;
                            var Nombre1:string;
                            var Director1:string;
                            var Ttipo1:Tipo;
                            var Epoca1:string;
                            var Persona_prin1:string;
                            var Tema1:string;
                            var Personaje1:string;
                            var Autobiografia1:boolean);
  begin
  inherited mostrar(Editorial1,Dir_Edit1,Per_Contac1,Tlfno1,
                                   Poblacion1,Provincia1,Autor1,Ano_Public1,
                                   Nombre_Nov1,ISBN1,Nombre1,Director1,
                                   Ttipo1,Epoca1,Persona_prin1,Tema1,Personaje1,
                                   Autobiografia1);
  personaje1:=personaje;
  autobiografia1:=autobiografia;
  end;
  destructor Tbiografia.Destroy;
  begin
    inherited destroy;
  end;
end.

Tomare en cuenta tu consejo, yo por ahora solo me limito a aprender, llebo solo 1 mes programando en Delphi y es mi primer lenguaje de programacion orientado a objetos que aprendo, la pregunta mas logica es....¿Podria utilizar siempre Propiedades cuando exista una jerarquia de clases?

Bien dicen que el hábito no hace al monje. Esto no tienen nada que ver con polimorfismo, es una horrible chapuza para utilizar virtual y override.

Es imperdonable que una clase haga referencia implícita o explícita a datos de sus descendientes. Cada método "virtual" carga con todos los posibles parámetros de la jerarquía. ¿Qué pensará este profesor? Hazle este cuestionamiento:

Supongamos que se distribuye el código compilado (dcus) de esta biblioteca sin proporcionar el código fuente. Y supongamos que en un futuro, quienes adquirieron la biblioteca necesitan ampliar la jerarquía añadiendo nuevos descendientes que introducen nuevos atributos. ¿Cómo se puede mantener el "polimorfismo"? Tendríamos que añadir los nuevos parámetros al procedimiento de la clase base. ¡Pero no disponemos del código fuente de la clase base!

De paso pregúntale para qué quiere todos esos var que anteceden a los parámetros ya que éstos no se modifican en la rutina.

Y en mi opinión, dotar de tantos parámetros a un método no es más que una forma de disfrazar de OOP a una programación procedural a la antigüita.

Mal, muy mal. Como te comenté: tómalo con reserva.

// Saludos

No soy Román pero te contesto.

Si, si se puede hacer.

Aquí te pongo como sería tu clase padre usando solamente propiedades:

Código Delphi [-]
  TBiblioteca = class // Clase padre
  private
    FEditorial: string;
    FDir_Edit: string;
    FPer_Contac: string;
    FTlfno: string;
    FPoblacion: string;
    FProvincia: string;
  public
    constructor Create;
    destructor Destroy; override;

    // Propiedades de la clase
    property Editorial: string 
      read FEditorial
      write FEditorial;
    property Dir_Edit: string;
      read FDir_Edit
      write FDir_Edit;
    property Per_Contact: string
      read FPer_Contact
      write FPer_Contact;
    property Tlfno: string
      read FTlfno
      write FTlfno;
    property Poblacion: string
      read FPoblacion
      write FPoblacion;
    property Provincia: string
      read FProvincia
      write FProvincia;
  end;

Ahora, una clase descendiente de TBiblioteca podría ser así:

Código Delphi [-]
  TNovela = class(TBiblioteca) //Clase que hereda de Biblioteca
  private
    FAutor:string;
    FAno_Public:Integer;
    FNombre_Nov:string;
    FISBN:string;
  public
    constructor Create;
    destructor Destroy; override;

    // Propiedades de la clase
    property Autor: string
      read FAutor
      write FAutor;
    property Ano_Public: string
      read FAno_Public
      write FAno_Public;
    property Nombre: string
      read FNombre: string
      write FNombre;
    property ISBN: string
      read FISBN
      write FISBN;
  end;

Ahora, para darle valores a las propiedades de un objeto sería tan fácil como:

Código Delphi [-]
var
  Novela: TNovela;

begin
  Novela := TNovela.Create;
  Novela.Editorial := 'Editores Unidos'; // Esta propiedad es heredada
  Novela.Autor := 'Anónimo'; // Esta propiedad es exclusiva de TNovela
    // y sus descendientes.
end;

Espero que esto te aclare un poco el uso de las propiedades.



Saludos...

Je, je. Aquí me equivoco. Ya veo por que son var. ¡Válgame dios!

// Saludos

Lo mismo pensé yo... :eek: :eek:

¿De que me equivoqué o del "válgame dios"?

:D

// Saludos

polimorfismo
 

Ahora mismo me has descolocado.¿Lo que e hecho es una chapuza?, y si es asi...¿Como puedo solucionarlo??

Perdona pero estoy desconcertado, segun me dices, lo primero que deberia de haber hecho es transformar los parametros en propiedades, y no tengo ni idea de como hacer eso. Los var que hay puestos antes de cada parametro lo que dicen es que ese procedimiento va a devolver esos parametros al Form que uso para mostrar los datos.

polimorfismo
 

Soys rapidos,

A la excelente contestación de Maeyanes yo añadiría el polimorfismo en plena acción:

Código Delphi [-]
var Libro:TBiblioteca;
begin
  Libro := TNovela.Create(...);
 
end;

Libro podrá ser TBiblioteca, o cualquier otro descendiente.

saludos

Checa el ejemplo que te di. Las dos clases que modifiqué usan solamente propiedades (como debería ser) y al final un ejemplo de como asignarle valores.

Para obtener el valor de las propiedades solo tienes que hacer lo contrario, por ejemplo, desde un formulario:

Código Delphi [-]
procedure TFom1.Form1Show(Sender: TObject);
begin
  // Formulario con 2 edit:
  Edit1.Text := Novela.Editorial;
  Edit2.Text := Novela.Autor
end;

Ya con eso estás obteniendo el valor de las propiedades del objeto Novela.


Saludos...

Del "válgame dios"... :D


Me fui para atrás cuando vi ese código... :D

Revisa a fondo el ejemplo de Maeyanes

saludos

juer, que dificil es seguir este hilo con tanta actividad.... :D :D

mejor vuelvo mañana... o mejor.... no me meto que estoy sobrando :D

saludos compis

Tú no. Tu profesor!!

¿Solucionarlo? No sé qué decirte. Quizá, por dar el beneficio de la duda al profesor, sería bueno ver cuáles fueron los requerimientos originales de la práctica.

Empecemos con el hecho de que semánticamente hablando los métodos alta y mostrar no les encuentro ningún sentido. ¿Qué significa dar de alta un libro?

Para mí, en todo caso, significaría crear una instancia de la clase TLibro, llenar sus propiedades con datos proporcionados por el usuario y guardar la instancia en un almacenaje permanente como podría ser una base de datos.

Piénsalo así:

Si tienes una clase

Código Delphi [-]
type
  TLibro = class
    propiedades

    procedure Alta(parámetros);
  end;

implementation

procedure TLibro.Alta(parámetros);
begin
  propiedades := parámetros);
end;

Realmente te puedes ahorrar las clases y usar records:

Código Delphi [-]
type
  TLibro = record
    propiedades
  end;

procedure Alta(parámetros);

interface

procedure Alta(Libro: TLibro; parámetros);
begin
  Libro.propiedades := parámetros;
end;

con lo cual se quita el disfraz OOP a las clases.

// Saludos

No, si aquí el que sobra es el profesor :D

// Saludos

polimorfismo
 

El ejercicio era el siguiente.
Hay que crear un programa el cual permita al usuario introducir los datos por teclado de Prensa, Novela histarica, novela de ficcion, o novela biografica. Para ello debemos usar una jerarquia de clases, las cuales ya habeis visto. Para implementar el procedure alta, el cual llenara un array polimorfico donde almacenaremos los objetos, debemos usar la Herencia. Para el Procedimiento Mostrar deberemos usar Polimorfismo.
Visto lo visto, lo que me estais aconsejando es que empieze de 0 el programa verdad?

perplejo
 

wenas,simplemente decir k un p...mes pa esto.
soy kompañero d clase de liriko y la verdad es k tanto kalentamiento y tanto "averiguar x vuestra cuenta" estaba empezando a moskearme.eso hay k vivirlo pa saber l k sentiamos,sin k nos explicara nada.dando kosas x sabidas y x corregidas.

al final tokara l de sempre,aprender cada uno x su cuenta

enga,salu2

Hola johnyy, bienvenido a estos foros, te recomiendo que le des una leidita a este hilo y ya que estamos en esto, también revisa la guía de estilo.


Saludos!!

Wow, gracias, me quede vico

Creo que te confundiste al leer el problema. Según entiendo, tanto el procedimiento Alta como Mostrar no deben ser miembros de una clase. Lo único que tienen que hacer es llenar y mostrar un arrar de objetos respectivamente.

Ahora, el poliformismo en esto sería algo como:

Código Delphi [-]
var
  // Arreglo de objetos del tipo biblioteca
  Bibliografia: array [0..99] of TBiblioteca; 
 
// ...
 
procedure Alta(ABiblio: TBiblioteca; Index: Integer);
begin
  Bibliografia[Index] := ABiblio
end;

Para llamar a Alta se podría hacer de la siguiente forma:

Código Delphi [-]
begin
  Alta(Novela, 1); // Agregas un objeto de tipo TNovela
  Alta(Biografia, 2) // Agregas un objeto de tipo TBiografia
end;

Con esto ya estás haciendo uso del poliformismo. Esto es solo un ejemplo de como podría ser. Ya la implementación final queda de tu cuenta.



Saludos...

bueno vale lo tendre en cuenta,pero no creo que sea para tanto:)

Si quieres que en lo futuro se lean tus mensajes y se atiendan tu dudas, claro que es para tanto. La verdad que para algunos (si no es que muchos) de nosotros es muy difícil tratar de comprender ese tipo de escritura. Tu primer mensaje no lo leí más allá de la segunda línea por lo mismo.



Saludos... :)

hola muy buenas,quisiera hacer una pregunta por curiosidad: ¿el polimorfirsmo es utilizado con frecuencia en la oop?

gracias de antemano

Si te refieres a crear tú tus propias clases pensando polimórficamente para
despues usarlo... pues en casos como estos sip; que dicho sea de paso, es
algo frecuente.

Usarlo de forma insconciente, o sin darte cuenta.... pues mucho más de lo
que crees, aunque no he mirado la VCL a fondo para comprobarlo, estoy muy
seguro de que internamente Delphi usa el concepto, ya que da mucha
libertad.

Declaras una variable como Tcomponent y despues puedes asignarle un
descendiente que tenga la clase.

-Un caso común es acceder a FindComponent para encontrar un determinado
control en el form en tiempo de ejecución. FindComponent busca un
Tcomponent, pero puede ser un TEdit, Tpanel o cualquiera que sea
descendiente, que en realidad lo serán casi todos los controles que tienes en
un Form.

- Realizar un bucle sobre todos los TEdits con FormX.Components[i]. (más de
lo mismo), cada boton o panel, se trata como si fuera un Tcomponent, que es
la clase base para ambos controles que he mencionado.

- Incluso recorrer todos los campos que tiene una tabla, tú trabajas
con Tfield, pero el campo en cuestión puede ser un TIntegerfield, TFloatField,
etc., que son clases hijas de TField.

Esto mismo se podría hacer sin uso del polimorfismo, pero no cabe duda que
ahorras lineas de código de esta forma, amén de usar una característica muy
potente del lenguage.

Moraleja: Es importante aprender los conceptos y practicar tanto con polimorfismo, herencia, etc.

saludos y espero te sirva.

saludos

si que me ha servido,gracias;)

a ver como resumo todo este tema en clase,jeje

polimorfismo
 

Hola amigos ¡

Me e estado pensando si comentaros, pero la verdad, me e decidido a hacerlo. Expuse todo este tema en clase, y el profesor(por llamarle de alguna manera) solo se reitero. Las propiedades son para los objetos visuales, con los metodos que habeis escrito en todo este hilo, segun el no estan los datos encapsulados, resumiendo, segun esta persona todo lo que hay escrito en este hilo es la "tipica basura que nos podemos encontrar por Internet". Yo, visto lo visto, pienso que es mejor que me lo mire por mi cuenta. Sabeis de algun manual sobre DELPI que merezca la pena?GRacias por adelantado.

¿Así que según tu "maestro", el pasar 10 líneas de parámetros a un metodo es encapsular datos? :p

Lo único triste del caso es que tus demás compañeros se queden con lo que les está "enseñando" su "maestro".

Pues para empezar, la misma ayuda de Delphi tiene mucha información, el único inconveniente (para algunos), es que se encuentra en inglés.

También te puedes bajar el libro de la Cara Oculta de Delphi 4, el link no lo tengo a la mano pero no faltará quien te lo proporcione.



Saludos...

Pues aquí: La Cara Oculta de Delphi 4
:D

Pues te agradecemos que hayas confiado en nosotros al hacerlo.

Para no repetir lo dicho por otros compañeros; simplemente Escribe
TStringList en el editor de código de delphi, mantén la tecla CTRL presionada
y haz clic sobre la palabra. Irás al código fuente de Delphi y
comprobarás por tí mismo que Delphi usa propiedades para todo. Puedes mirar
libremente cómo está hecho delphi internamente, todos los controles y todas
las Clases, y por supuesto, se usan propiedades.

Si "tenemos que darle la razón a tu profesor" tendríamos que poner en
entredicho uno de los mejores Lenguajes de programación existentes, cuya
robustez, eficiencia y filosofía de POO ha sido más que demostrada y alabada.
Y habría que ponerlo en entredicho porque todas las clases tienen
propiedades, sea un control visual o no. Tú decides quien lleva razón... si
éste foro de internet.... o tu profesor :D ;) :D.

Saludos