17 respuestas en este tema

[giulichajari]

Bueno una unidad con orientacion a objetos entre otras que hice..quiero que la corrijan.

 

La cree escribiendo.. 

php

property NombreAtributo

y luego el compilador genero el codigo de los setter colocandolos en "private"

delphi

unit UProducto;
 
interface
type
Tproducto = class
  private
    Fcosto: Double;
    Fiva: double;
    Fprecio: Double;
    Fpedir: boolean;
    Fsubcategoria: string;
    Fcategoria: string;
    Fpreciob: Double;
    Fporcganancia: Double;
    Fprecioa: Double;
    Fidproducto: integer;
    Fnombre: string;
    Fmarca: string;
    Fganancia: Double;
    procedure Setcategoria(const Value: string);
    procedure Setcosto(const Value: Double);
    procedure Setganancia(const Value: Double);
    procedure Setidproducto(const Value: integer);
    procedure Setiva(const Value: double);
    procedure Setmarca(const Value: string);
    procedure Setnombre(const Value: string);
    procedure Setpedir(const Value: boolean);
    procedure Setporcganancia(const Value: Double);
    procedure Setprecio(const Value: Double);
    procedure Setprecioa(const Value: Double);
    procedure Setpreciob(const Value: Double);
    procedure Setsubcategoria(const Value: string);
    property idproducto:integer read Fidproducto write Setidproducto;
    property categoria:string read Fcategoria write Setcategoria;
    property subcategoria:string read Fsubcategoria write Setsubcategoria;
    property marca:string read Fmarca write Setmarca;
    property costo:Double read Fcosto write Setcosto;
    property precio:Double read Fprecio write Setprecio;
    property iva:double read Fiva write Setiva;
    property pedir:boolean read Fpedir write Setpedir;
    property nombre:string read Fnombre write Setnombre;
    property preciob:Double read Fpreciob write Setpreciob;
    property precioa:Double read Fprecioa write Setprecioa;
    property ganancia:Double read Fganancia write Setganancia;
    property porcganancia:Double read Fporcganancia write Setporcganancia;
  public
    constructor create(idproducto:integer;categoria:string;subcategoria:string;marca:string;
    costo:Double;precio:Double;iva:Double;pedir:Boolean;nombre:String;preciob:Double;precioa:double;
    ganancia:Double;porcganancia:Double);
end;
implementation
 
{ Tproducto }
 
 
 
constructor Tproducto.create(idproducto: integer; categoria, subcategoria,
  marca: string; costo, precio, iva: Double; pedir: Boolean; nombre: String;
  preciob, precioa, ganancia, porcganancia: Double);
begin
 
    Fidproducto:=idproducto;
    Fcategoria:=categoria;
    Fsubcategoria:=subcategoria;
    Fmarca:=marca;
    Fcosto:=costo;
    Fprecio:=precio;
    Fiva:=iva;
    Fpedir:=pedir;
    Fnombre:=nombre;
    Fpreciob:=preciob;
    Fprecioa:=precioa;
    Fganancia:=ganancia;
    Fporcganancia:=porcganancia;
end;
 
procedure Tproducto.Setcategoria(const Value: string);
begin
  Fcategoria := Value;
end;
 
procedure Tproducto.Setcosto(const Value: Double);
begin
  Fcosto := Value;
end;
 
procedure Tproducto.Setganancia(const Value: Double);
begin
  Fganancia := Value;
end;
 
procedure Tproducto.Setidproducto(const Value: integer);
begin
  Fidproducto := Value;
end;
 
procedure Tproducto.Setiva(const Value: double);
begin
  Fiva := Value;
end;
 
procedure Tproducto.Setmarca(const Value: string);
begin
  Fmarca := Value;
end;
 
procedure Tproducto.Setnombre(const Value: string);
begin
  Fnombre := Value;
end;
 
procedure Tproducto.Setpedir(const Value: boolean);
begin
  Fpedir := Value;
end;
 
procedure Tproducto.Setporcganancia(const Value: Double);
begin
  Fporcganancia := Value;
end;
 
procedure Tproducto.Setprecio(const Value: Double);
begin
  Fprecio := Value;
end;
 
procedure Tproducto.Setprecioa(const Value: Double);
begin
  Fprecioa := Value;
end;
 
procedure Tproducto.Setpreciob(const Value: Double);
begin
  Fpreciob := Value;
end;
 
procedure Tproducto.Setsubcategoria(const Value: string);
begin
  Fsubcategoria := Value;
end;
 
end.

No genero los getter.

Y por ultimo programe la implementación del constructor..

 

Agradezco me corrijan

[genriquez]

 

 

Hola, creo que los procedimientos que debes ejecutar fuera de la clase, deben ir en Protected si se heredarán para ser usados o modificados desde una clase heredada o Public si se deben ejecutar desde afuera.

 

En cuanto a las propiedades no pueden estar en una sección privada, debería estar en la sección Public o en su defecto en Published si son clases para utilizar en el IDE y publicar estas propiedades en el Object Inspector.

 

De resto esa clase está bien hasta aquí.

 

Saludos.

[Agustin Ortu]

La sintaxis general es
 

delphi

property Nombre: [b]Tipo [/b]read Getter write Setter;

Donde en la seccion read debe especificarse bien:

• Una funcion sin argumentos que retorne Tipo
• Una variable de instancia de Tipo

Ademas, al especificar read, estamos diciendo implicitamente que (obviamente teniendo en cuenta las reglas de visibilidad segun sea private, protected, public) el valor de la propiedad se puede leer
 
En la seccion write debe especificarse bien:

• Un procedimiento con un solo argumento (pudiendo ser un agumento const), de Tipo
• Una variable de instancia de Tipo

El write implicitamente esta diciendo que el valor de esa propiedad se puede modificar
 
En tiempo de ejecucion, al usar una propiedad, en el caso en que estemos asignando un valor (operador de asignacion comun, :=) se ejecuta lo que dice la seccion write. Es decir, si hay un metodo, se ejecuta ese metodo y se envia como argumento el valor que estamos asignando
 

delphi

property Nombre: string read GetNombre write SetNombre;
 
procedure TClas.SetNombre(const Value: string);
begin
  FNombre := Value;
end;
 
procedure TClase.GetNombre: string;
begin
  Result := FNombre;
end;
 
...
var
  c: TClase;
begin
  ... 
 
  c.Nombre := 'Pedro';   // estas dos lineas son equivalentes
  c.SetNombre('Pedro');
end;

Para el caso de las lecturas es lo mismo

delphi

var
  c: TClase;
begin
  ..
  ShowMessage(c.Nombre);
  ShowMessage(c.GetNombre);
end;

Por que automaticamente se mandan los getter y setter a la seccion private?

 

Simplemente porque la propiedad es suficiente para hacer las dos cosas; en un solo "metodo" agrupas dos. El codigo queda mas legible y ademas a la hora de escribir es mucho mas comodo

 

Si sacamos las propiedades, y dejamos los getter y setter como publicos, tendriamos el doble de metodos disponibles para usar en la clase

 

Ademas el codigo queda mas limpio usando propiedades. Usando el setter estamos obligados a escribir entre parentesis el valor a escribir

delphi

c.SetNombre('Pedrito');

A mi siempre me molestan los parentesis. Que pasa si ahi dentro en lugar de pedrito hay que mandar, algo que tambien tiene parentesis (operaciones matematicas, otorgar formato al string, invocar al metodo de otra clase que requiere parametros, etc)

 

 

Las propiedades mas que nada existen para ayudar al desarrollador. Son mas "lindas", mas limpias y mas comodas de usar que los getter y los setter. La funcion que cumplen es la misma que la de ellos 

 

Luego hay algunos usos mas sofisticados de las propiedades, como por ejemplo acceder mediante un indice

 

 

Ejemplos:

delphi

ShowMessage(Strings.Items[0]);
  Strings[5] := 'Pedrito'

Cuando el equivalente podria ser

delphi

ShowMessage(Strings.GetItem(0))
  Strings.SetItem(5, 'Pedrito')

[giulichajari]

De acuerdo...dentro de todo esta bien..convengamos que es una clase solamente, no hay mucha complejidad..mas adelante posteare mas..

 

Y en la clase factura que voy a exponer mas adelante tengo:

delphi

Fproductos: array of Tproducto;

y no me lo coloca en el constructor..esta mal declarado?

 

ya lo solucione con:

delphi

type
arrayProductos = Class (TObjectList<Tproducto>);

[genriquez]

Bien, esta parte es la más interesante,  cuando manejas una lista o un arreglo de objetos, lo ideal es que definas la clase padre, para que todos los "hijos" puedan ir en la lista.

 

Regreso al ejemplo de los objetos de dibujo. 

 

TPunto = Class(TObject);

TLinea = Class(TPunto);

TRectangulo = Class(TLinea);

TCirculo = Class(TLinea).

 

Se crea todo el manejo de las listas para TPunto y nada más que para el,   así administrar una línea, un rectángulo o un circulo es indiferente para la lista.

 

En una POO bien diseñada,  lo único que se debe cambiar es la rutina de adición del objeto a la lista,  luego el manejo de cada objeto es prácticamente autonómo.

 

Saludos.

[giulichajari]

Bien, esta parte es la más interesante,  cuando manejas una lista o un arreglo de objetos, lo ideal es que definas la clase padre, para que todos los "hijos" puedan ir en la lista.

 

Regreso al ejemplo de los objetos de dibujo. 

 

TPunto = Class(TObject);

TLinea = Class(TPunto);

TRectangulo = Class(TLinea);

TCirculo = Class(TLinea).

 

Se crea todo el manejo de las listas para TPunto y nada más que para el,   así administrar una línea, un rectángulo o un circulo es indiferente para la lista.

 

En una POO bien diseñada,  lo único que se debe cambiar es la rutina de adición del objeto a la lista,  luego el manejo de cada objeto es prácticamente autonómo.

 

Saludos.

Entonces tu dices no hacerlo con TObjectList.. aunque se podria

 

Y seria entonces crear la lista como una clase que luego requiere instanciarce...aqui encontre una pagina:

 

http://www.devmedia....em-delphi/23962

 

Esta en portugues pero mirando el codigo..crea una clase "listaclientes" que luego instancia con metodos adicionar y remover..

 

Es eso?

 

Saludos

[giulichajari]

una cosa que no encuentro es como declarar la implementacion de una clase hija... por el tema de la asignacion de valores a los atributos heredados de la clase padre..

Por ejemplo FacturaA hereda de Factura y se especializa con 3 atributos de alicuotas...

 

el constructor se llama NuevoCompA

delphi

constructor TFacturaA.NuevoCompA(alicuota21, alicuota10, alicuota27: Double);
begin
  Falicuota21:=alicuota21;
  Falicuota10:=alicuota10;
  Falicuota27:=alicuota27;
end;

este es el constructor de la clase padre

delphi

constructor NuevoComp(Persona:TPersona;importe:Double;fechae:string;
     horae,FCAE:string;sucursal:integer;efectivo:Double;vuelto:Double);

[genriquez]

Veamos el ejemplo de heredad de las clases.

delphi

TPunto = Class(TObject)
Private
   FX : Integer;
   FY : Integer;
   FColor  : TColor;
 Public
     Constructor Create(aX, aY : Integer; aColor : 
TColor); Virtual;
     Procedure Dibujar(Canvas : TCanvas); Virtual;
End;
 
TLinea = Class(TPunto)
Private
  FX1 : Integer;
  FY1 : Integer;
Public
  Constructor Create(Ax, aY, aX1, aY1 : Integer; aColor : TColor); 
Reintroduce;
  Procedure Dibujar(Canvas : TCanvas); Override;
End;
 
Implementation
 
Constructor TLinea.Create(aX, aY, aX1, aY1 : Integer; aColor : TColor);
Begin
    Inherited Create(aX, aY, aColor);  ///Invoca el 
constructor del padre
    FX1 := aX1;
    FY1 := aY1;
End;

En este caso, se maneja una sola lista que puede ser una colección de objetos de tipo punto, lo único que debe modificarse es la adición de los objetos a la lista, el resto, cada objeto debería ser lo más autónomo posible.
 
Ej.

delphi

Var
   ListaDibujo = TList<TPunto>;

Para dibujar en un canvas sería algo así.

delphi

  Var Punto : TPunto;
 
  For Punto in ListaDibujo do
     Punto.Dibujar(Image1.Canvas);

  La lista, puede contener objetos de todos los tipos heredados de TPunto y los entenderá bien a la hora de dibujarlos.
 
Esto aplica para cualquier tipo de programación orientada a objetos. 
 
Saludos.

[giulichajari]

Ok entiendo...

 

entonces la herencia quedaria(y ya con la lista):

delphi

constructor TFacturaA.NuevoCompA(alicuota21, alicuota10, alicuota27: Double);
var
listaProductos: TList<Tproducto>;
begin
  Inherited Create(Persona,importe,fechae,horae,sucursal,efectivo,vuelto);
  Falicuota21:=alicuota21;
  Falicuota10:=alicuota10;
  Falicuota27:=alicuota27;
end;

despues bueno habria que agregar productos y/o quitarlos..

Para lo mismo pienso usar una interfaz ya que depende del tipo de factura es como se agregan los productos se calculan los impuestos y totales..etc.. Lo publicare mas adelante asi lo miran..

el CAE lo obtengo del servidor de AFIP..por eso no obligo a establecerlo en el constructor..

[giulichajari]

Ahora bien..otra duda..una clase que hereda de otra? puede implementar una interfaz.

Porque he buscado como decir en codigo que una clase implementa una interfaz.. usando InterfacedObject..pero se pueden declarar las dos cosas a la vez?

 

Porque facturaA hereda al igual que FacturaB de factura..entonces.. puedo tener una interfaz para las operaciones como por ej:

delphi

unit UIOperaciones;
 
interface
type
 IOperacionesAB = interface
  procedure calculoAlicuotas(iva:Double;subtotal:Double);
 end;
 
 IOperaciones = interface
 
   procedure imprimir();
   procedure guardarPDF();
   procedure agregaProducto();
 end;
implementation
 
end.

porque la idea mia es que cada clase de factura implemente los metodos como le corresponde.,.que es ese el concepto de interfaz..

 

entonces como declaro que facturaA hereda de factura e implementa una interfaz?

mo sera que la clase padre factura debe implementar la interfaz entonces todas las clases hijas redefinen los metodos

[Agustin Ortu]

Podes usar delegación. Busca sobre ello en la docwiki. La palabra clave de interes es implements

 

Básicamente declaras una clase como que implementa una interface, pero dicha implementación no se hace en la clase, sino no en otra. Luego, podes usar la clase como si realmente implementara la interface

 

Revisa este ejemplo:

 

delphi

unit Unit2;
 
interface
 
type
  IImprimible = interface
    ['{F470F0CB-FB49-4215-8E17-85862237E7E2}']
    procedure Imprimir(const PageCount: Integer = 1);
  end;
 
  TDocumento = class abstract
  end;
 
  TFactura = class(TDocumento, IImprimible)
  private
    FImpresora: IImprimible;
    function GetImpresora: IImprimible;
  public
    constructor Create(const AImpresora: IImprimible);
    property Impresora: IImprimible read GetImpresora implements IImprimible;
//    property Impresora: IImprimible read FImpresora implements IImprimible; equivalentes
  end;
 
  TImprimirdorFacturaA = class(TInterfacedObject, IImprimible)
    procedure Imprimir(const PageCount: Integer = 1);
  end;
 
  TImprimirdorFacturaB = class(TInterfacedObject, IImprimible)
    procedure Imprimir(const PageCount: Integer = 1);
  end;
 
implementation
 
{ TFactura }
 
constructor TFactura.Create(const AImpresora: IImprimible);
begin
  inherited Create;
  FImpresora := AImpresora;
end;
 
function TFactura.GetImpresora: IImprimible;
begin
  Result := FImpresora;
end;
 
{ TImprimirdorFacturaB }
 
procedure TImprimirdorFacturaB.Imprimir(const PageCount: Integer);
begin
  Writeln('Se esta imprimiendo la Factura B...');
end;
 
{ TImprimirdorFacturaA }
 
procedure TImprimirdorFacturaA.Imprimir(const PageCount: Integer);
begin
  Writeln('Se esta imprimiendo la Factura A...');
end;
 
end.

Uso:

delphi

uses
  System.SysUtils,
  Unit2 in 'Unit2.pas';
 
var
  fcA, fcB: IImprimible;  
begin
  try
    fcA := TFactura.Create(TImprimirdorFacturaA.Create);
    fcB := TFactura.Create(TImprimirdorFacturaB.Create);
 
    fcA.Imprimir;
    fcB.Imprimir;
 
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[giulichajari]

Ok..y el diseño que planteo es bueno? Aunque depende lo ke cada uno piensa.

Enviado desde mi SM-G530M mediante Tapatalk

[giulichajari]

 

 

La delegación se caracteriza por "reutilización selectiva", en cambio en herencia es un "todo o nada".

A ver si entiendo un poco

De hecho coloque en uioperaciones.pas dos interfaces..dado que las facturas A y B tiene por ejemplo el iva discriminado.. y la C el iva incluido..

Pero ademas: los metodos imprimir y guardarPDF y demas yo los necesito en las clases concretas.. es decir yo en el sistema voy a instanciar..de acuerdo a las condiciones de iva una factura A o B o C pero no una factura..osea la clase madre no se instancia digamos.. estos metodos podrian estar en la clase madre y ser implementados de distinta manera..

La otra alternativa es usar interfaces...que es parecido a una clase abstracta.. son metodos cuya implementacion se desarrolla en cada clase

 

podria ser factura una clase con metodos abstractos (los que estan en la interfaz) y que luego los defina factura a y b..

 

lo que no me permite el compilador es esto que hiciste agustin:

delphi

TFactura = class(TDocumento, IImprimible)

osea colocar la clase padre y una interfaz...

 

asi me quedo:

delphi

unit UFactura;
 
interface
uses
UPersona,Uproducto,UIOperaciones,Generics.collections,SysUtils;
type
 
  TFactura = class abstract
  private
    FCAE: string;
    Fimporte: Double;
    Fpersona: TPersona;
    Fvuelto: Double;
    Fefectivo: Double;
    Fhorae: string;
    Fsucursal: integer;
    Ffechae: string;
 
    procedure SetCAE(const Value: string);
    procedure Setefectivo(const Value: Double);
    procedure Setfechae(const Value: string);
    procedure Sethorae(const Value: string);
    procedure Setimporte(const Value: Double);
    procedure Setpersona(const Value: TPersona);
 
    procedure Setsucursal(const Value: integer);
    procedure Setvuelto(const Value: Double);
 
     property CAE:string read FCAE write SetCAE;
     property persona:TPersona read Fpersona write Setpersona;
     property importe:Double read Fimporte write Setimporte;
     property fechae:string read Ffechae write Setfechae;
     property horae:string read Fhorae write Sethorae;
     property sucursal:integer read Fsucursal write Setsucursal;
     property efectivo:Double read Fefectivo write Setefectivo;
     property vuelto:Double read Fvuelto write Setvuelto;
 
     public
     constructor NuevoComp(Persona:TPersona;importe:Double;fechae:string;
     horae:string;sucursal:integer;efectivo:Double;vuelto:Double);
     procedure calculoAlicuotas(iva:Double;subtotal:Double);virtual;abstract;
     procedure agregaProducto(p:Tproducto);virtual;abstract;
     procedure quitaProducto(p:Tproducto);virtual;abstract;
     procedure imprimir();virtual;abstract;
     procedure guardarPDF(rutaDestino:string);
     destructor Destroy;
 end;
 
  TFacturaA = class (TFactura)
 
    private
    Falicuota21: Double;
    Falicuota27: Double;
    Falicuota10: Double;
    procedure Setalicuota10(const Value: Double);
    procedure Setalicuota21(const Value: Double);
    procedure Setalicuota27(const Value: Double);
 
        property alicuota21:Double read Falicuota21 write Setalicuota21;
        property alicuota10:Double read Falicuota10 write Setalicuota10;
        property alicuota27:Double read Falicuota27 write Setalicuota27;
    public
       const
        iva21 = 21;
        iva10 = 10.5;
        iva27 = 27;
       constructor NuevoCompA(alicuota21:Double;alicuota10:Double;alicuota27:Double);
       destructor Destroy;
     procedure calculoAlicuotas(iva:Double;subtotal:Double);
     procedure agregaProducto(p:Tproducto) ;
     procedure quitaProducto(p:Tproducto);
     procedure imprimir();
     procedure guardarPDF(rutaDestino:string);
end;
   TFacturaB = class (TFactura)
 
    private
    Falicuota21: Double;
    procedure Setalicuota21(const Value: Double);
      property alicuota21:Double read Falicuota21 write Setalicuota21;
    public
      const
        iva = 21;
      constructor NuevocompB(alicuota21:Double);
      destructor Destroy;
      procedure agregaProducto(p:Tproducto);
     procedure quitaProducto(p:Tproducto);
end;
implementation
 
{ TFactura }
 
 
 
 
destructor TFactura.Destroy;
begin
 
end;
 
 
procedure TFactura.guardarPDF(rutaDestino: string);
begin
 
end;
 
constructor TFactura.NuevoComp(Persona: TPersona; importe: Double; fechae,
  horae: string; sucursal: integer; efectivo, vuelto: Double);
begin
 
  Fimporte:=importe;
  Fpersona:=Persona;
  Fvuelto:=vuelto;
  Fefectivo:=efectivo;
  Fhorae:=horae;
  Fsucursal:=sucursal;
  Ffechae:=fechae;
 
end;
 
 
 
procedure TFactura.SetCAE(const Value: string);
begin
  FCAE := Value;
end;
 
procedure TFactura.Setefectivo(const Value: Double);
begin
  Fefectivo := Value;
end;
 
procedure TFactura.Setfechae(const Value: string);
begin
  Ffechae := Value;
end;
 
procedure TFactura.Sethorae(const Value: string);
begin
  Fhorae := Value;
end;
 
procedure TFactura.Setimporte(const Value: Double);
begin
  Fimporte := Value;
end;
 
procedure TFactura.Setpersona(const Value: TPersona);
begin
  Fpersona := Value;
end;
 
 
procedure TFactura.Setsucursal(const Value: integer);
begin
  Fsucursal := Value;
end;
 
procedure TFactura.Setvuelto(const Value: Double);
begin
  Fvuelto := Value;
end;
 
{ TFacturaA }
 
procedure TFacturaA.agregaProducto(p: Tproducto);
var
prod:Tproducto;
begin
 
end;
 
procedure TFacturaA.calculoAlicuotas(iva, subtotal: Double);
begin
 
end;
 
destructor TFacturaA.Destroy;
begin
 
end;
 
procedure TFacturaA.guardarPDF(rutaDestino: string);
begin
 
end;
 
procedure TFacturaA.imprimir;
begin
 
end;
 
constructor TFacturaA.NuevoCompA(alicuota21, alicuota10, alicuota27: Double);
var
listaProductos: TList<Tproducto>;
begin
  Inherited Create();
  Falicuota21:=alicuota21;
  Falicuota10:=alicuota10;
  Falicuota27:=alicuota27;
end;
 
procedure TFacturaA.quitaProducto(p: Tproducto);
begin
 
end;
 
procedure TFacturaA.Setalicuota10(const Value: Double);
begin
  Falicuota10 := Value;
end;
 
procedure TFacturaA.Setalicuota21(const Value: Double);
begin
  Falicuota21 := Value;
end;
 
procedure TFacturaA.Setalicuota27(const Value: Double);
begin
  Falicuota27 := Value;
end;
 
{ TFacturaB }
 
procedure TFacturaB.agregaProducto(p: Tproducto);
begin
 
end;
 
destructor TFacturaB.Destroy;
begin
 
end;
 
constructor TFacturaB.NuevocompB(alicuota21: Double);
begin
  Inherited Create();
  Falicuota21:=alicuota21;
end;
 
procedure TFacturaB.quitaProducto(p: Tproducto);
begin
 
end;
 
procedure TFacturaB.Setalicuota21(const Value: Double);
begin
  Falicuota21 := Value;
end;
 
end.

[Agustin Ortu]

Por que no te lo permite? Que error arroja?

 

Puede no permitirte compilar porque en la clase te falta implementar los metodos de la interface

 

En ese caso tenes dos formas, o bien los implementas, o bien usas delegacion, que es justamente lo que mostre arriba con el implements

 

Yo no pondria en la clase TFactura nada relacionado con imprimir ni con guardar a PDF

 

Eso lo trabajaria en una rama aparte. Los reporteadores lo hacen de manera similar, por eso es necesario colocar componentes "extras", los filtros, que son los que realizan el trabajo

 

Yo haria esto:

delphi

type
  IExportadorFacturas = interface
    procedure Exportar(AFactura: TFactura; const ANombreArchivo: string); 
  end;
 
  TExportadorPDF = class(TInterfacedObject, IExportadorFacturas)
    procedure Exportar(AFactura: TFactura; const ANombreArchivo: string); 
  end;
 
  TExportadorExcel = class(TInterfacedObject, IExportadorFacturas)
    procedure Exportar(AFactura: TFactura; const ANombreArchivo: string); 
  end;

Luego, uso en codigo:

delphi

procedure ExportarComoPdf(AFactura: TFactura; const ANombreArchivo: string);
var
  AExportador: IExportadorFacturas;
begin
  AExportador := TExportadorPdf.Create;
  AExportador.Exportar(AFactura, ANombreArchivo);
end;
 
procedure BotonExportarPdfClick(Sender: TObject);
var
  AFactura: TFactura;
begin
  AFactura := // obtener factura de algun repositorio de datos, etc
  try
    ExportarComoPdf(AFactura);
  finally
   AFactura.Free
  end;
end;

[giulichajari]

Claro..lo que yo no tengo es el numero que aparece abajo de interface en tu codigo... y ademas tengo la interface en un archivo aparte..tiene algo que ver?

 

 

 

Yo no pondria en la clase TFactura nada relacionado con imprimir ni con guardar a PDF

 

es correcto porque ademas son metodos independiente del tipo o clase de factura. Guardar se guarda nomas un archivo..lo que cambia es la forma del pdf nomas..

 

Y el error que da es

 

[dcc32 Error] UFactura.pas(48): E2291 Missing implementation of interface method IInterface.QueryInterface

 

es conocido lo busque en google y claro poniendo la palabar INterfacedObject se soluciona.. pero no me sirve

[Agustin Ortu]

No creo que sea problema del Guid. Eso lo generas desde el IDE apretando control shift g

No importa que esté en un archivo aparte, siempre y cuando lo pongas en el

Podes publicar el código conflictivo?

[giulichajari]

esta es la clase factura

delphi

unit UFactura;
 
interface
uses
UPersona,Uproducto,UIOperaciones,Generics.collections,SysUtils;
type
 
  TFactura = class
  private
    FCAE: string;
    Fimporte: Double;
    Fpersona: TPersona;
    Fvuelto: Double;
    Fefectivo: Double;
    Fhorae: string;
    Fsucursal: integer;
    Ffechae: string;
    Fproductos: TList<Tproducto>;
 
    procedure SetCAE(const Value: string);
    procedure Setefectivo(const Value: Double);
    procedure Setfechae(const Value: string);
    procedure Sethorae(const Value: string);
    procedure Setimporte(const Value: Double);
    procedure Setpersona(const Value: TPersona);
 
    procedure Setsucursal(const Value: integer);
    procedure Setvuelto(const Value: Double);
    procedure Setproductos(const Value: TList<Tproducto>);
 
     property CAE:string read FCAE write SetCAE;
     property persona:TPersona read Fpersona write Setpersona;
     property importe:Double read Fimporte write Setimporte;
     property fechae:string read Ffechae write Setfechae;
     property horae:string read Fhorae write Sethorae;
     property sucursal:integer read Fsucursal write Setsucursal;
     property efectivo:Double read Fefectivo write Setefectivo;
     property vuelto:Double read Fvuelto write Setvuelto;
     property productos:TList<Tproducto> read Fproductos write Setproductos;
     public
     constructor NuevoComp(Persona:TPersona;importe:Double;fechae:string;
     horae:string;sucursal:integer;efectivo:Double;vuelto:Double;productos:TList<Tproducto>);
     procedure calculoAlicuotas();
     procedure agregaProducto(p:Tproducto);
     procedure quitaProducto(p:Tproducto);
 
     destructor Destroy;
 end;

cuando hago

delphi

TFacturaA = class (TFactura, IOperacionesAB)

me da ese error.. y si pongo punto y coma despues del parentesis.. me dice

 

[dcc32 Error] UFactura.pas(54): E2029 '=' expected but identifier 'Falicuota21' found

 

alicuota21 es el primer parametro que tengo..

 

igual logre hacerlo implementando las interfaces en la clase madre factura luego cada factura sobreescribe lo que necesita..por ejemplo la factura c no implementa calculoAlicuotas..solo agregar producto por ej..estaria bien?

[giulichajari]

Bueno en internet encontre que el detalle puede ser una clase que compone a la clase factura.. entonces pense tener 3 clase hijas heredando de detalle..un detalle por cada tipo de factura respectivamente. a su vez se puede componer de una cabecera y de un pie.

 

Lo que si la clase factura no tendria porque especializarse..porque de detalle heredan los distintos tipos..

Al momento de facturar se ingresa el CUIT o se selecciona un cliente... de acuerdo a su condicion tributaria se creara un objeto detalle a b o c para poder crear un objeto factura.

me parece mejor que tener tres clases de factura..aunque se puede implementar de las dos formas..