Otra duda con OOP

[Paulao]

Hay como yo declarar una classe y esta classe crear Edit's y en otro form yo hacer una instancia desta classe de forma que yo pongo un Edit en mi form y esse Edit ya fue leido en la classe, dejame explicar:
En un Form1 hago la declaracion de las classes.
En otro Form2 yo cargo esta classe, pero asi.
Necesito que en el Form2 yo haga una lectura de unos Edits, pero yo no queria poner asi:
Edit.Text := Mivariable, pero que esto ya este declarado en Form1(construcion de mis classes) y en Form2 yo apenas cargo mis Edits y ellos ya hacen lo que tiene que hacer, sin la necesidad de Escribir codigos en Form2 para apontar para los Edits.

[[fer21unmsm]]

Quisiera ayudarte, pero la verdad no entiendo tu pregunta

[[Delphius]]

Hola Paulao,
A costa de demorarme en mi trabajo, y más sabiendo lo dificil que se me hace estar sin internet, yo opino que sería mejor que nos redactes tu diseño de la clase.

Esta vez reconozco, al igual que fer21unmsm, que no se te entendió lo que buscas hacer.

EDITO:
Por cierto, hubiera sido lo mejor tratar a esto en el hilo anterior ¿O es que se trata de otra práctica en POO?

Saludos,

[Paulao]

Noe facile quando no se habla bien.
Tengo 2 Form, Form1 y Form2. En el Form1 yo tengo mi classe TCalculadora(Ejemplo).
En Form2 yo la llamo y hago los calculos. En Form2, tengo 3 Edits para la entrada de datos y 4 botones(Soma, Sub, Multi y Divide). En este Form2, yo tengo que cargar mis variables que van a ser usada en el calculo. Entonces vamos a la implementacion de la classe asi:

Código Delphi [-]
TCalculadora = class
 public
  function soma(v1,v2:Integer):Integer;
 ...

function soma(v1,v2:Integer):Integer;
begin
 result := v1 + v2;
end;

Esto en Form1. En Form2 yo tengo la instancia asi:

Código Delphi [-]
var
 Form2: TForm;
 Calc : TCalculadora;
implementation
.....
procedure TForm1.btnSomaClick(Sender: TObject);
var
 vl1,vl2: Integer;
begin
 vl1 := StrToInt(Edit1.Text);
 vl2 := StrToInt(Edit2.Text);
 Edit3.Text := IntToStr(Calc.Soma(vl1,vl2));
end;

Mi gustaria de hacer, que los parametros que en Form2 son: vl1 y vl2 ya seria cargados en la declaracio da classe y no necesitaba hacer en Form2, de formas que en Form seria asi:

Código Delphi [-]
 Edit3.Text := IntToStr(Calc.Soma(V1,V2));

Yo no necesitaba de tener variables en este Form para hacer el calculo, yo ya pongava el valor en los edits y listo. Mi pregunta es: Hay como hacer? Es posible? Quedo mas claro?

[[maeyanes]]

Hola...

Si te entendí bien podrías hacer algo como:

Código Delphi [-]
type
  TForm2 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    // demás componentes
  private
    function GetValor1: Double;
    function GetValor2: Double;
  public
    property Valor1: Double read GetValor1;
    property Valor2: Double read GetValor2;
  end;

implementation

functino TForm2.GetValor1: Double;
begin
  if Trim(Edit1.Text) <> '' then
    Result := StrToFloat(Edit1.Text)
  else
    Result := 0
end;

functino TForm2.GetValor2: Double;
begin
  if Trim(Edit2.Text) <> '' then
    Result := StrToFloat(Edit2.Text)
  else
    Result := 0
end;

procedure TForm2.btnSumaClick(Sender: TObject);
begin
  Edit3.Text := FloatToStr(Calc.Suma(Valor1, Valor2))
end;

Espero que el ejemplo te de una idea de como lo podrías hacer...


Saludos...

[[enecumene]]

Paulao, se você tiver a dificuldade em falar o espanhol que você pode usar o traductore gratuitous na linha que está na rede mas, você pode a pôr em sua língua e talvez você eu posso traduzir em o mais possível.

Cumprimentos.

[[Delphius]]

Veamos, entonces lo que buscas es que no se tengan que llamar a una función Suma con parámetros sino que estraiga los datos desde la propia clase?

¿Esto lo que buscas?:

Código Delphi [-]
Edit1.Text := IntToStr(Calc.Soma);

Para ello debes seguir el diseño que yo te aporté. Antes de llamar a Soma se necesita pasar de algún modo los valores a la clasy y que ésta los guarde. ¿Qué se necesita? Tener dos campos, sus respectivos métodos Get y Set y sus propiedades públicas.

En efecto esto:

Código Delphi [-]
TCalculadora = class
private
  // esto son los campos, variable auxiliares que guardarán los valores
  // de los operandos
  FOp1, FOp2: integer; //real... dependerá de lo que busques
  // luego van sus métodos Set y Get.
  procedure SetOp1(Value: integer);
  procedure SetOp2(Value: integer);
  function GetOp1: integer;
  function GetOp2: integer;
public
  // tus propiedades públicas
  property Op1: integer read GetOp1 write SetOp1;
  property Op2: integer read GetOp2 write SetOp2;
  // otros métodos
  function Soma: integer;
  function Resta: integer;
  ...
end;

De este modo, por ejemplo, cuando tu necesites almacenar el operando1, haces esto:

Código Delphi [-]
Calc.Op1 := StrToInt(Edit1.Text);

Internamente el compilador se encarga de llamar al método SetOp1. y queda guardada en FOp1 el valor adecuado.

Ahora sólo debe programarse a los métodos para leer dichos campos privados y hacer la operación necesaria:

Código Delphi [-]
function TCalculadora.Soma: integer;
begin
  result := FOp1 + FOp2;
end;

Es un diseño similar al que te ofrecí en el otro hilo.

¿Es esto lo que buscas?

Saludos,

[[maeyanes]]

Hola...

Empezado por Delphius

¿Qué se necesita? Tener dos campos, sus respectivos métodos Get y Set y sus propiedades públicas.

En efecto esto:

Código Delphi [-]
TCalculadora = class
private
  // esto son los campos, variable auxiliares que guardarán los valores
  // de los operandos
  FOp1, FOp2: integer; //real... dependerá de lo que busques
  // luego van sus métodos Set y Get.
  procedure SetOp1(Value: integer);
  procedure SetOp2(Value: integer);
  function GetOp1: integer;
  function GetOp2: integer;
public
  // tus propiedades públicas
  property Op1: integer read GetOp1 write SetOp1;
  property Op2: integer read GetOp2 write SetOp2;
  // otros métodos
  function Soma: integer;
  function Resta: integer;
  ...
end;

Si al momento de asignar o leer un valor de una propiedad no se necesita hacer ningún tipo de operación o validación, no es necesario usar los métodos Get y Set. Se puede hacer simplemente algo como:

Código Delphi [-]
property Op1: Integer read FOp1 write FOp1;
property Op2: Integer read FOp2 write FOp2;

Saludos...

[[Delphius]]

Empezado por maeyanes

Hola...



Si al momento de asignar o leer un valor de una propiedad no se necesita hacer ningún tipo de operación o validación, no es necesario usar los métodos Get y Set. Se puede hacer simplemente algo como:

Código Delphi [-]property Op1: Integer read FOp1 write FOp1;
property Op2: Integer read FOp2 write FOp2;



Saludos...

Si lo se amigo. Se que en ocasiones puede que sea innecesesario estos métodos. Más yo preferí comentarselo puesto que esto proviene de la idea de practicar POO y es normal encontrarse con estos métodos. Paulao redactó el tema original en este hilo.

Si Paulao está interesado en aprender los conceptos POO me parece bien hacerle comentar que el capítulo 6 de la Cara Oculta de Delphi 4 puede serle útil para comprender los conceptos básicos de POO con Delphi.

Saludos,

[Paulao]

Hola, tengo si interes en aprender POO y los mas fundamentales comandos. Yo quiero desde el comienzo si. Gracias por la ayuda de todos.

[Delfino]

Aqui puedes aprender paso a paso lo de la OOP en Delphi..

[Paulao]

Ahora hizo mi calculadora y quedo bueno. Abajo mis codigos: Esta es la Unit donde yo implente mis classes.

Código Delphi [-]
unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TCalculadora = class
  private
    FOp1, FOp2: integer;
    procedure SetOp1(Value: integer);
    procedure SetOp2(Value: integer);
    function GetOp1: integer;
    function GetOp2: integer;
  public
    property Op1: integer read GetOp1 write SetOp1;
    property Op2: integer read GetOp2 write SetOp2;
    function Soma: integer;
    function Subtrai: integer;
    function Multiplica: integer;
    function Divide: double;
    function Fatora: integer;
    function Resta: integer;

end;

implementation

{ TCalculadora }

function TCalculadora.Divide: double;
begin
  result := FOp1 / FOp2;
end;

function TCalculadora.Fatora: integer;
var
  N,i:Integer;
begin

  N := FOp2;
  for i := 1 to N - 1 do
    N := N * i;
  result := N;
end;

function TCalculadora.GetOp1: integer;
begin
  Result := FOp1;
end;

function TCalculadora.GetOp2: integer;
begin
  Result := FOp2;
end;

function TCalculadora.Multiplica: integer;
var
  i,j:Integer;
begin
  i := 1;
  j := FOp1;
  while i < FOp2 do
  begin
    FOp1 := Fop1 + j;
    inc(i);
  end;
  Result := FOp1;
end;

function TCalculadora.Resta: integer;
begin

end;

procedure TCalculadora.SetOp1(Value: integer);
begin
  FOp1 := Value;
end;

procedure TCalculadora.SetOp2(Value: integer);
begin
  FOp2 := Value;
end;

function TCalculadora.Soma: integer;
begin
  result := FOp1 + FOp2;
end;

function TCalculadora.Subtrai: integer;
begin
  result := Fop1 - Fop2;
end;

end.

Ahora otra Unit donde este mi llamada a la classe

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Unit2, StdCtrls, Buttons;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    BitBtn1: TBitBtn;
    BitBtn2: TBitBtn;
    BitBtn3: TBitBtn;
    BitBtn4: TBitBtn;
    BitBtn5: TBitBtn;
    procedure BitBtn1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure BitBtn2Click(Sender: TObject);
    procedure BitBtn3Click(Sender: TObject);
    procedure BitBtn4Click(Sender: TObject);
    procedure BitBtn5Click(Sender: TObject);
  private
    { Private declarations }
    FCalc: TCalculadora;
  public
    { Public declarations }
    property Calc: TCalculadora read FCalc write FCalc;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
  FCalc.Op1 := StrToInt(Edit1.Text);
  FCalc.Op2 := StrToInt(Edit2.Text);
  Edit3.Text := IntToStr(Calc.Soma);
end;

procedure TForm1.BitBtn2Click(Sender: TObject);
begin
  FCalc.Op1 := StrToInt(Edit1.Text);
  FCalc.Op2 := StrToInt(Edit2.Text);
  Edit3.Text := IntToStr(Calc.Subtrai);
end;

procedure TForm1.BitBtn3Click(Sender: TObject);
begin
  FCalc.Op1 := StrToInt(Edit1.Text);
  FCalc.Op2 := StrToInt(Edit2.Text);
  Edit3.Text := IntToStr(Calc.Multiplica);
end;

procedure TForm1.BitBtn4Click(Sender: TObject);
begin
  FCalc.Op1 := StrToInt(Edit1.Text);
  FCalc.Op2 := StrToInt(Edit2.Text);
  Edit3.Text := FloatToStr(Calc.Divide);
end;

procedure TForm1.BitBtn5Click(Sender: TObject);
begin
  FCalc.Op1 := StrToInt(Edit1.Text);
  FCalc.Op2 := StrToInt(Edit2.Text);
  Edit3.Text := IntToStr(Calc.Fatora);
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  FreeAndNil(FCalc);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  FCalc := TCalculadora.Create;
end;

end.

Esta funciono con poco codigo, que es mi abjetivo.