Primeros pasos OOP

[Kreyser]

Hola a todos, y ante todo, gracias por vuestro tiempo.;)

Tengo unas clases tal que TCliente, TProveedor, que heredan de TObject y disponen de metodos para el acceso y trabajo con sus conjuntos de datos.
Tengo por otra parte sus ventanas correspondientes TvtCliente, TvtProveedor, que heredan de TForm y contienen la interface de acceso y trabajo con los datos.

Mi duda es si al iniciar el trabajo con una de estas entidades, (Cliente, Proveedor...), debería:

1.-Instanciar TCliente y que este instancie un TvtCliente...
2.-Instanciar un TvtCliente, que instancie a su vez un TCliente...

Lo he realizado de las dos formas y no tengo nada claro cual de ellas sería más correcta.

Es posible q me esté "enredando" y debíera unificar las clases en una, heredando de TvtCliente y añadiendole los métodos de TCliente???.

Espero haberme explicado bien.:rolleyes:
Aceptaré de buen grado, cualquier sugerencia o comentario.
Saludos.:p

[Neftali [Germán.Estévez]]

No se si acabo de entenderte bien, pero creo que deberías mantener separadas esas clases; Por un lado tienes las clases de lógica de negocio (Clientes, Proveedores, ...) y por otro lado las ventanas (la interficie). Creo que no deberían derivar las unas de las otras.

De esa forma puedes variar/modificar la interficie sin modificar las clases de negocio.

Es más, debes poder trabajar con las clases de negocio (Cliente, Proveedor,...) sin necesidad de interficie; Hacerlo desde código.

Lo lógico es que los métodos de trabajo estén en las clase de negocio (Cliente) como por ejemplo, crear, Insertar, borrar, buscar,... y desde la interficie (ventanas) sólo hagas las llamadas a estos métodos.

[Kreyser]

OK, Neftali, así lo tengo en la actualidad... pero mi duda es de cara a la manera de Instanciar ambas clases...

Desde mi MDIForm, cuando accedo a una opción de esas entidades (por ejemplo, Consulta de Clientes), debería:

1.- Instanciar la ventana, y desde ella instanciar la clase Cliente??.
2.- Instanciar la clase cliente y desde ella instanciar la ventana??.
3.- Es indiferente??...

Gracias de nuevo.:p

[Neftali [Germán.Estévez]]

Entiendo que la clase Cliente siempre está por debajo de la ventana de cliente. Es decir, la clase puede vivir por sí sola, pero no así la ventana.
La ventana necesita la clase y no al revés.

[Kreyser]

Ok, ese argumento tiene mucha lógica.
Gracias de nuevo.:D

[rastafarey]

Mira unejemplo.

Clase op;

clase dm

clase ops //es un listados de op

ops pose un variable d tipo op para manejar listas multiples

op tiene una variable de dm para menejo de a data

por suspuesto lo smetodos de dm son astractos y los de op tambien

entonces tienes una clase que hereda tform tendria una variable tipo ops para menejar sucontenido porsupuesto los metodos de la forma deben ser abtractos para que puedan llamar a los metodos de la clase que heredo y no de la base.

De esta manera puedes manejar tus clases de negocio independientemente ya que cada quien tendra que sobresescribir los metodos abstractos y form llamara al herdados por cada quien.

Bueno aqui tiene un codigo para un objeto persistente.

me disculpan por el codigo pero no se como poner el link a lo sarchivoa atachados.

unit OP;

interface

Uses Contnrs;

Type

__TIdOP = Int64;

__TMD = Class;

__TOP = Class
private
FId: __TIdOP;
FEsproxy: Boolean;
procedure SetEsproxy(const Value: Boolean);
Protected
Md : __TMD;
Public
Constructor Create; Virtual;
Procedure Leer; Virtual;
Procedure Guardar; Virtual;
Procedure Borrar; Virtual;
Property Id : __TIdOP Read FId;
Property Esproxy: Boolean read FEsproxy write SetEsproxy;
End;

__TMD = Class
Protected
Function DbLeerOP(pOP: __TOP): __TIdOP; Virtual; Abstract;
Function DbGuardarOP(pOP: __TOP): __TIdOP; Virtual; Abstract;
Procedure DbBorrarOP(pOP: __TOP); Virtual; Abstract;
Function PxLeerOP(pOP: __TOP): __TIdOP; Virtual; Abstract;
Function PxGuardarOP(pOP: __TOP): __TIdOP; Virtual; Abstract;
Procedure PxBorrarOP(pOP: __TOP); Virtual; Abstract;
End;

__TOPClase = Class Of __TOP;

__TOPS = Class(TObjectList)
private
FIndice : Integer;
function GetEsUltimo: Boolean;
function GetPrimero: Boolean;
function GetVacio: Boolean;
Protected
function GetIndice(Ind: Integer): __TOP;
procedure SetIndice(Ind: Integer; const Value: __TOP);
function GetOP: __TOP;
Function Nuevo(__OPClase: __TOPClase): __TOP;
Function Existe(Const cIds: Array Of Const): Boolean; Virtual;
Public
Constructor Create;
Procedure Primero;
Procedure Ultimo;
Procedure Anterior;
Procedure Siguiente;
procedure Insertar(cIndice: Integer; pOP: __TOP);

Function Agregar(pOP: __TOP): Integer;
function Extraer(cIndice: TObject): __TOP;
function Remover(pOP: __TOP): Integer;
function IndeceDe(pOP: __TOP): Integer;

Property EsPrimero: Boolean Read GetPrimero;
Property EsUltimo: Boolean Read GetEsUltimo;
Property Vacio: Boolean Read GetVacio;
Property OP: __TOP Read GetOP;
Property Indices[Ind: Integer]: __TOP Read GetIndice Write SetIndice;
Property Indice: Integer Read FIndice;
End;

Const
csIdOPNulo = -1;

implementation

uses SysUtils, Classes;

{ __TOP }

procedure __TOP.Borrar;
begin
If FEsproxy Then
Md.PxBorrarOP(Self)
Else
Md.DbBorrarOP(Self)
end;

constructor __TOP.Create;
begin
inherited Create;
FId := csIdOPNulo;
FEsproxy := False;
Md := Nil;
end;

procedure __TOP.Guardar;
begin
If FEsproxy Then
FId := Md.PxGuardarOP(Self)
Else
FId := Md.DbGuardarOP(Self)
end;

Procedure __TOP.Leer;
begin
If FEsproxy Then
FId := Md.PxLeerOP(Self)
Else
FId := Md.DbLeerOP(Self)
end;

procedure __TOP.SetEsproxy(const Value: Boolean);
begin
FEsproxy := Value;
end;

{ __TOPS }

procedure __TOPS.Anterior;
begin
Dec(FIndice);
end;

constructor __TOPS.Create;
begin
inherited Create;
FIndice := -1;
end;

function __TOPS.GetOP: __TOP;
begin
Result := __TOP(Items[FIndice]);
end;

function __TOPS.GetEsUltimo: Boolean;
begin
Result := FIndice >= Count;
end;

function __TOPS.GetPrimero: Boolean;
begin
Result := FIndice < 0;
end;

procedure __TOPS.Primero;
begin
FIndice := 0;
end;

procedure __TOPS.Siguiente;
begin
Inc(FIndice);
end;

procedure __TOPS.Ultimo;
begin
FIndice := Count-1;
end;

function __TOPS.Agregar(pOP: __TOP): Integer;
begin
Result := inherited Add(pOP);
end;

function __TOPS.Extraer(cIndice: TObject): __TOP;
begin
Result := __TOP(inherited Extract(cIndice));
end;

function __TOPS.IndeceDe(pOP: __TOP): Integer;
begin
Result := inherited IndexOf(pOP);
end;

procedure __TOPS.Insertar(cIndice: Integer; pOP: __TOP);
begin
inherited Insert(cIndice, pOP);
end;

function __TOPS.Remover(pOP: __TOP): Integer;
begin
Result := inherited Remove(pOP);
end;

function __TOPS.GetIndice(Ind: Integer): __TOP;
begin
Result := __TOP(inherited Items[Ind]);
end;

function __TOPS.GetVacio: Boolean;
begin
Result := Count > 0;
end;

procedure __TOPS.SetIndice(Ind: Integer; const Value: __TOP);
begin
inherited Items[Ind] := Value;
end;

function __TOPS.Existe(const cIds: array of Const): Boolean;
begin
Result := False;
end;

function __TOPS.Nuevo(__OPClase: __TOPClase): __TOP;
begin
Result := __OPClase.Create;
Agregar(Result);
end;

end.

[Neftali [Germán.Estévez]]

...me disculpan por el codigo pero no se como poner el link a lo sarchivoa atachados.
Debajo de la zona donde escribes los mensajes, están los iconos y debajo un espacio titulado "Aditional Options"; Utiliza el botón de "Admnistrar adjuntos" para añadir los ficheros que desees.