crear clases en delphi

[alextmb]

hola amigos de clubdelphi.com nesecito de su ayuda, ojala y alguien pudiera proporcionarme un ejemplo de como crear una clase en tiempo de ejecucion en delphi y responder si ¿Puedo crear clases como si fuera un arreglo?.
Necesito crear 20 clases similares.De antemano Gracias

[Sinaloense]

No se pueden crear clases, lo que se hace es instanciar objetos.

[dec]

Hola,

A ver si nos entendemos.

Una clase es una clase, y un objeto es un objeto. Un objeto es la instancia de una clase. Una clase es como un molde de un objeto. No tienes que crear veinte clases (creo), sino que tienes que crear 20 objetos de una determinada clase.

¿Cómo se instancia una clase de objeto en Delphi? ¿Cómo se crean objetos de una clase? Mediante los constructores conque cada clase cuenta, que no son sino unos métodos "especiales" que inicializan variables, preparan un objeto, en fin, de una determinada clase.

Su contraparte está en los "destructores", que se utilizan para liberar memoria, por ejemplo, o para cualquier otra tarea que hubiera que llevar a cabo cuando se destruye un determinado objeto de cierta clase.

¿Pero cómo creas un objeto, demonios? Te estarás preguntando. No soy yo el más indicado para estar aquí ahora escribiendo esto, sin modestia lo digo, pero, en definitiva, tendrás que fijarte en el constructor o constructores (porque puede haber más de uno) de la clase en cuestión, para saber cómo tienes que tratar con ello.

¿Un ejemplo? De acuerdo. Creemos una instancia de la clase "TEdit", por ejemplo, que sabes que es un control visual de los que vienen en la pestaña "Standard" de la paleta de componentes de Delphi.

¿Dónde se encuentra definida la clase "TEdit"? En la unidad "StdCtrls" (de Standard Controls). Pues bien, lo primero sería requerir esa unidad, para poder trabajar con la clase "TEdit", ya sabes:

Código Delphi [-]
uses
  StdCtrls;

Ahora tendremos que buscarle un hogar a la instancia del objeto que queremos crear. Digamos que una variable del tipo de objeto que queremos crear nos puede venir bien. Así que declaremos una variable de ese tipo en donde sea... bueno, en donde sea que nos haga falta, por ejemplo, supongamos que vamos a utilizar un objeto "TEdit" que crearemos en tiempo de ejecución en un formulario:

Código Delphi [-]
unit Unit2;

interface

uses
  Forms, StdCtrls;

type
  TForm2 = class(TForm)
  private
    MiEdit: TEdit; // aquí estoy
  end;

var
  Form2: TForm2;
  MiEdit: TEdit; // o aquí también

implementation

{$R *.dfm}

var
  MiEdit: TEdit; // incluso aquí

end.

¿Ves la variable "MiEdit" declarada en la sección "private" de la clase "TForm2"? También ves cómo pudimos declararla fuera de la clase "TForm2", en la cláusula "interfaz" de la unidad que contiene el formulario, e incluso pudimos declararla en la cláusula "implementation".

Igualmente podríamos haberla declarado dentro de un procedimiento, función o método. Por ejemplo, imagina que dentro de la cláusula "implementation" de la unidad anterior tuviéramos algo así:

Código Delphi [-]
procedure TForm2.Button1Click(Sender: TObject);
var
  MiEdit: TEdit;
begin

end;

Estaríamos declarando una variable capaz de contener la referencia de un objeto de la clase "TEdit" dentro del método "Button1Click", en este caso.

Muy bien. ¿Pero cómo creo el objeto? Vamos a ello. Sigamos con la variable que declaramos en el método susomentado. Así creamos una instancia de la clase "TEdit":

Código Delphi [-]
procedure TForm2.Button1Click(Sender: TObject);
var
  MiEdit: TEdit;
begin
  MiEdit := TEdit.Create(Self);
  MiEdit.Parent := Self;


  MiEdit.Free;
end;

Vamos por líneas. Primero hacemos uso del constructor de la clase "TEdit", el cual nos pide como parámetro un componente "propietario" para el objeto "TEdit" que queremos crear. Nosotros le damos como padre el "Form2", es decir, como sabes, la variable "Self" contiene una referencia al objeto en cuyo método estamos trabajando, que en este caso es "Form2". El propietario del "TEdit" se encargará de liberar la memoria ocupada con este en su destrucción, en la del propietario mismo, aunque nosotros podemos encargarnos de esa tarea también por nuestra cuenta.

El objeto, a partir de ahí, está ya en memoria, vivito y coleando, pero, no le veríamos sino fuera por la siguiente línea. Este "TEdit" es muy suyo, y, como otros controles similares, además de un "propietario" nos solicita un "padre". Es como si nos preguntara, "está bien, aquí estoy, pero, ¿dónde quieres que me muestre?" Y nosotros le respondiéramos con las mismas, ¡en el mismo formulario, y deja ya de ser pesado y muéstrate ya!

Y el "TEdit" obediente se muestra... ¡pues no faltaba más!

Pero una instrucción más abajo, oh, amigo, la vida es así, destruimos el "TEdit", liberamos su memoria y adiós, ahí te pudras. Porque ya no nos hacía falta, naturalmente. De otro modo podríamos seguir usándolo hasta cuando hubiéramos querido.

¿Diferencias entre declarar la variable "TEdit" en la clase del formulario, en la cláusula "interface", en la cláusula "implementation" o en el procedimiento, como hemos hecho? Bueno. Eso para otra pregunta, que ya estoy viendo que me estoy enrollando demasiado con esta, y no sé yo hasta dónde vamos a llegar...

Pero... ¡casi se me olvida! ¡Tú querías crear veinte clases, digo objetos! ¡De una tacada! (?) ¡Y en tiempo de ejecución! ¡Vade retro! Bueno. Pues como casi con todo en esto de la programación, habrá varias formas de enfocar las cosas, y en parte tiene que ver qué pretendemos conseguir.

Si te explayas un poco más en lo que necesitas, tal vez alguien pueda ofrecerte más información. Yo te diría respondería que puedes crear un arreglo de los "TEdit" (seguimos con el ejemplo), o puedes utilizar una variable que contenga (o vaya conteniendo) los "TEdit" que necesites... no sé qué decirte, porque tampoco sé qué necesitas realmente.

Aquí te dejo algo de código escrito a vuela pluma, que seguramente contenga errores, pero tal vez pueda darte alguna idea. Se admiten sugerencias a todas horas de lunes a viernes y sábados y festivos que no sean de guardar.

Código Delphi [-]
uses
  Contnrs; // Contiene la clase TObjectList

var
  // Un array preparado para contener 20 TEdit
  FEditsA: array [0..19] of TEdit;

procedure TForm1.Button1Click(Sender: TObject);
var
  i: integer;
begin
  Randomize;
  for i := 0 to High(FEditsA) do
  begin
    FEditsA[i] := TEdit.Create(Self);
    FEditsA[i].Parent := Self;
    FEditsA[i].SetBounds(Random(Self.Width-100),
      Random(Self.Height-20), 100, 20);
  end;
end;

var
  FEditsB: TObjectList;

procedure TForm1.Button2Click(Sender: TObject);
var
  nEdit: TEdit;
begin
  nEdit := TEdit.Create(Self);
  nEdit.Parent := Self;
  Randomize;
  nEdit.SetBounds(Random(Self.Width-100),
    Random(Self.Height-20), 100, 20);

  if not Assigned(FEditsB) then
    FEditsB := TObjectList.Create;

  FEditsB.Add(nEdit);

  ShowMessage(Format('Edits en FEditsB: %d', [FEditsB.Count]));
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FEditsB.Free;
end;

No comento el código porque creo que más o menos podrá entenderse, y porque ya me he cansado un poco de aporrear las teclas... pero puedes comentar lo que te parezca del mismo, que aquí estaremos en cuanto hayamos descansado un poco.

[alextmb]

perdon es que no me di ha entender en mi primer mensaje, soy novato y como que me enredo un poco al explicarme, pero si por ain va mi duda, lo que nesecito hacer es crear una clase y en esa clase tengo que crear 20 image con el codigo que me has dado me explica muchas cosa, pero tambien me abre algunas dudas.
¿que es lo que hace la linea?

Código Delphi [-]
MiEdit.Free;

y que a que se refiere utilizando la palabra self?

por resolver mis dudas y escribir tanto gracias.

[dec]

Hola,

perdon es que no me di ha entender en mi primer mensaje, soy novato y como que me enredo un poco al explicarme, pero si por ain va mi duda, lo que nesecito hacer es crear una clase y en esa clase tengo que crear 20 image (...)

Bueno. A lo mejor es que nosotros nos hemos empeñado en verlo de la manera en que no era... Ahora creo comprender más o menos a lo que te refieres. Luego luego te explicaré porqué digo que logro comprenderlo más o menos.

¿que es lo que hace la linea?

Código Delphi [-]
MiEdit.Free;

Bueno, según la ayuda de Delphi "Free" es un método de la clase "TObject" (de la que descienden todos los objetos en Delphi, directa o indirectamente) que sirve para:

Empezado por Ayuda de Delphi

Destroys an object and frees its associated memory, if necessary.

y que a que se refiere utilizando la palabra self?

Se trata de un identificador que "pone Delphi" para...

Empezado por Ayuda de Delphi

Within the implementation of a method, the identifier Self references the object in which the method is called.

Ahora, si te parece, vamos a lo de porqué decía que comprendo más o menos lo que quieres decir cuando dices que quieres crear una clase que contenga 20 "TImage" (supongo que te refieres a objetos de la clase "TImage" cuando hablas de imágenes).

Yo no soy muy bueno en la programación orientada a objetos (bueno, en realidad en ningún paradigma de programación, pero, no estoy aquí ahora para quejarme). Lo que se me ocurre es que para lo que quieres hacer habrá más de una solución, más de un posible camino que andar.

¿Usarás todas las imágenes desde un principio? ¿Se trata, por el contrario, de ir añadiendo imágenes según sea necesario, pero es posible que nunca se llegue al límite de 20 imágenes? Son preguntas que se me ocurren, porque, tengo mis dudas sobre lo que pretendes conseguir.

Si te has fijado en el código de arriba se muestra una forma de crear un "Array" capaz de contener veinte "TEdit": lo mismo podría contener "TImage", como puedes suponer. También se muestra en el código de arriba cómo pueden crearse "TEdit" y se van añadiendo en una variable de tipo "TObjectList" (te remito a la ayuda de Delphi sobre esta clase).

Bueno. Pues lo mismo que se declaró una variable "Array" y una variable "TObjectList" en las clásulas "interface", "implementation", dentro de la clase "TForm2" y dentro de un método de esta última clase, nada te impide declarar variables de esas características dentro de la declaración de tu propia clase, de la que estés llevando a cabo.

No sé. Intuyo que tanto a ti y a mí nos hacen falta un par de hervores en cuanto a programación orientada a objetos se refiere, entre otras, porque ya puestos, porqué no. Ya me dirás qué sacas en claro de todo este rollo que he soltado.

[[Lepe]]

Despues de la extensa, eXtupenda y amena explicación de Dec, solo me queda añadir que Yo usaría un TObjectList por comodidad (no tienes que establecer los límites ni modificarlos al añadir objetos, se hace solo, además permite ordenar los objetos y sobre todo destruirlos de una forma muy facil; todos de una sola tacada o bien destruir uno solo) y tambien porque queda un código más limpio.

Tambien te remito a la Búsqueda de los foros en donde se ha hablado mucho sobre los TObjectList.

Código Delphi [-]
var L:TobjectList;
     i:Integer;
begin
  L := TobjectList.Create(true); // al destruir la lista se destruyen todos
  for i:=0 to 2000 do
  begin
     L.Add(Tedit.Create(Self); // lo creo y lo añado a la lista
     Tedit(L.items[i]).Parent := self ; accedo al objeto a través de la lista. Sin usar variables
  end;
  Sleep(3000);
  Freeandnil(L); // libero la lista y todos los Edits de una tacada.
end;

Saludos

[Alcolea]

Hola a atodos:

Me entusiasma el tema y voy a meter mi cuchareta. Te recomiendo encarecidamente que leas "La Cara oculta de Delphi 4" a partir de la página 127 donde comienza a explicar todo lo relacionado con la POO, o sea, la creación de clases, las relaciones que existen entre unas y otras a través de la herencia y todo un conjunto de cuestiones que es preciso dominar para enredarse con el tema de manera apropiada.

Como ya alguien te explicó las clases las pudieras ver como "moldes" que definen el comportamiento de todos los objetos que se instansien de ella, puedes ver a todos los botones de tu aplicación como "variables" pertenecientes al tipo TButton.

Un ejemplo sencillo:

Una clase para manejar empleados (esto lo vi en un libroy lo modifiqué, no está completo pero te ayudará)


TEmpleado = Class;
private
Nombre : String;
Cargo : String;
FechaIng : Date;
Salario : Real;

{En la sección private he declarado los atributos de la clase, algo así como las propiedades que caracterizarían a cada empleado, si piensas hacer una clase para manejar gráficos quizás debas declarar como uno de los atributos de esta un objeto Canvas. Todo lo que se declare en la sección private no podrá ser accedido desde otra Unit, a no ser a través de algún método de la clase destinado al efecto}

public
constructor CreaEmpleado(ANombre, ACargo : String; AFechaIng : Date; Salario : Real);

{El constructor, como te explicaron es un "método especial" que hace lo que ya te dijeron, y que puede haber varios dentro de una clase ya que un objeto puede crearse de varias formas, digamos que puedes cargarlo desde los datos guardados en el disco duro o crearlo desde cero en tiempo de ejecución, o puedes no implementar un constructor si no es necesario ya que todas las clases tiene uno predefinido llamado create el cual inicializa todos los valores ,de la clase que sea que estés creando, desde cero, es decir, si es un valor lógico comienza como false; si es entero, en cero; una enumeración, por el primer valor de la enumeración; una string, con la cadena vacía; etc.}

procedure SetNombre(ANombre : String);
procedure SetNombre(ACargo : String);
procedure EliminarEmpleado;
procedure CalcularAumento;

end;

{Además del constructor tendrás que declarar los métodos de tu clase, y esto una de las cosas que marca la diferencia entre un registro y un objeto, los objetos llevan encapsulados dentro de si las funciones que hacen, quiero decir que donde quiera que lo llames le puedes aplicar al empleado que sea el método para calcular el aumento de la misma manera que al objeto Edit1 le aplicas el método Clear para borrar el texto (Edit1.Clear) ( Empleado1.Calcular Aumento ) , no sabemos que líneas de código tiene el método Clear pero funciona, después que hagas tu clase no te acordarás que fue lo que pusiste a cada método pero si la hiciste bien no te hará falta recordarlo, solo lamas el método y ya está }

implementation

{Acá en la implementación es donde se pone a cada método declarado el código ejecutable que tendrá. Observa que delante del nombre de cada método se pone el nombre de la clase a la que pertenece, pues si implementas mas de una clase en la Unit no indicar a que clase pertenece el método puede traer problemas por lo que esto es obligatorio}

procedure TEmpleado.SetNombre(ANombre : String);
begin
Nombre := ANombre
end;

procedure TEmpleado.SetNombre(ACargo : String);
begin
Cargo := ACargo
end;

////////////////////////////////////////////////////////////////////

¿Cómo utilizar la clase?... de la misma manera que utilizas las clases que ya existen, declarar los objetos instancias de la clase de las variadas maneras que ya te explicaron y no olvidar llamar a alguno de los constructores posibles para darle vida a los objetos, solo después de creados podrás aplicar algunos de los métodos.

Espero que te pueda servir de algo mi explicación

Mi correo ruben06175@scu.jovenclub.cu