Trabajar con OOP - Duda
 

Tengo mis limitaciones en trabajar com OOP. Mi pidieron para yo hacer un teste asi:
Una calculadora con
Soma,Subtracion,Multiplicacion,Division y Fatoracion. Esto no tengo problemas en hacer si fuera asi, pero hay una cosa ahora que me complico. Tengo que hacer en un form en separado, todas las classes que implementan estas operaciones y en otro form, entonces llamar la classe y hacer la calculadora funcionar. Esto yo no se hacer. Estoy estudiando en el libro de Marco Cantù, pero una orientacion de usteds, que tiene ya buena pratica, suena mejor, pues se va directo hacia el problema. La multiplicción no puede tener "*". Las operaciones no tengo duda, solamente en las classes. Gracias a todos y creo que quedo listo.

Hola Paulao,
"Hablas" bastante bien el español, no puedo decir lo mismo a la inversa. No se portugués por lo que si algunas palabras que digo no se me entienden avisame por favor.

Entiendo tu preocupación. Y puede que te sea de ayuda. Antes que nada quisiera sacarme una pequeña duda, ¿A que te refieres con que no puedes emplear el operador *?

Si me preguntas por el tema de la clases, yo sólo veo una. Una clase calculadora que posee los métodos:
SetOperando1
SetOperando2

GetOperando1
GetOperando2

Aunque no se si tuviera sentido estos Get. Habría que considerar si se desea tener una calculadora "con Memoria".

SetOperacion
GetResultado

También puede ser útil tener un Método
Clear. Que vendría a ser la famosa tecla C.

Volviendo al tema de la "Memoria", si se desea guardar algún valor para operar, tal vez un SetM, haciendo cierta analogía con la famosa tecla M.

No se que tan elaborada debe ser la clase que realices. Si se busca recrear una calculadora de bolsillo.

Me gustaría saber como estás pensando o imaginando la clase. Si tu duda pasa sobre como declarar una clase, un ejemplo es como sigue:

Código Delphi [-]
TCalculadora = class
private
  // aqui viene la lista de campos y métodos privados
protected // no tiene utilidad en este caso
  // aqui la lista de los protegidos
public
  // aqui los públicos
published // tampoco tiene utilidad si se trata de una clase no de componente
end;

Un ejemplo más completo:

Código Delphi [-]
TCalculadora = class
private
  FOperando1, FOperando2: real;
  FOperador: TOperador;
  procedure SetOperando1(Value: real);
  function GetOperando1: real;
  ...
public
  property Operando1: real read GetOperando1 write SetOperando1;
  ...
end;

Y su implementación viene a ser algo así:

Código Delphi [-]
procedure TCalculadora.SetOperando1(Value: real);
begin
  if Value <> FOperando1
    then Foperando := Value;
end;

function TCalculadora.GetOperando1: real;
begin
  result := FOperando1;
end;

Pero el asunto es aquí que hacer y como implementar el "GetResultado". Una forma sencilla es esta:

Código Delphi [-]
function TCalculadora.GetResultado: real;
begin
  case Operador of
    opSuma: Result := ...
    opResta: Result := ...
    ....
  end;
end;

Pero he aquí que otra parte del problema radica en el manejo del estado interno de una calculadora. Y he squí que dependerá de que tan viable es llevar un control y manejo "real" de una calculadora. ¿A que me refiero con esto?

A que por lo general las calculadoras cuando ingresan un número o un operando se quedan en un estado de espera y pueden suceder muchas cosas aquí. Por ejemplo:

Cuando uno ingresa un número (SetOperando) la calculadora se queda esperando tres posibles eventos:
1. Que se sigan ingresando un número. Con lo que dicho Operando no fue terminado.
2. Si se presiona un operador, se confirma recién que el operando ha sido ingresado correctamente.
3. Si se presiona el "igual" se obtiene el valor del operando.

Y he aquí que en función del operador suministrado, la calculadora se queda esperando en otro estado:
1. Espera la orden del segundo operando.
2. Espera la orden igual.

¿Y si no se ha ingresado ningún operando, y se invoca a un operador? ¿Que sucede?

Por ello te quiero preguntar Paulao, que tanto se necesita controlar. ¿Debe ser algo simple? ¿Se busca recrear una calculadora de bolsillo?

No se si con esto te traigo más dudas que respuestas. Lo que pasa es que cuando se lleva un diseño POO lo primero a tener en cuenta es el grado de abstracción que se desea y fijar el límite de los requisitos.

Por lo pronto sería recomendable que me explicases a que se debe que no puedes emplear * ¿Te refieres a que debes hacerlo con sumas sucesivas?

Espero no haberte confundido más:o.

Saludos,

Siguiendo con la explicación, El tema de usar la clase en otra unit es relativamente sencillo.

Por empezar debes declarar la Unit en la parte uses de la Unit que hace uso de la otra. Supongamos que la clase está declarada en la Unit UCalculadora y que la Unit que hace uso de UCalculadora es Unit1, entonces te queda algo así:

Código Delphi [-]
Unit Unit1;

uses
Bla, Bla, bla, ...., UCalculadora;
....

Después necesitas tener una variable que sea del tipo TCalculadora. Si va a ser usada en cualquier parte de Unit1, entonces la declaramos en la parte de var. Si va a ser usada sólo en algún procedimiento, o función pues allí.

Supongamos (y es de esperar que sea este el caso) de que se lo usará a lo largo de la Unit1. Por tanto nos queda algo como esto:

Código Delphi [-]
...
var
  Form1: TForm1;
  Calculadora: TCalculadora;
...

Ahora sólo queda definir cuando se creará la instancia. Puede que sea lo más indicado en el evento onCreate del TForm. Por tanto lo hacemos allí:

Código Delphi [-]
procedure TForm1.FormCreate(Sender: TObject);
begin
  Calculadora := TCalculadora.Create;
end;

Y luego, definir cuando le damos muerte, es decir liberarlo. Puede que sea al momento de cerrar o terminar la aplicación:

Código Delphi [-]
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  Calculadora.Free;
  Action := caFree; // Garantizamos que se libere la memoria.
end;

Y listo, ya garantizamos el tiempo de vida de dicha instancia. Ahora sólo resta usar los métodos, funciones, eventos y/o propiedades cuando sea necesario.

Puede ser por ejemplo algo como esto:

Código Delphi [-]
procedure TForm1.ButtonSumarClick(Sender: TObject);
begin
  Calculadora.SetOperando(opSuma);
end;

¿Se entiende la idea?

Saludos,

Hola delphius, primero gracias por tu post. Si quieres aprender portugues, ven a brasil,eheheheheheheh! Mañana es miercoles y Fluminense va a engolir el Boca,ehheheheh!!!(2X1) Bien, vamos a la classe. Esto es un teste para una empresa y yo estoy sin pratica con OOP. Es solo una calculadora simples, con 3 edits. Dos para entrada de datos y otro para resultado. Pero yo hizo un poco diferente del suyo, pero esta me lo dando erro en la construction de la classe(variavel.Create>>>>Aca estas el error). Ello me lo pedieron que yo hago una multiplicacion sin el simbolo "*", no se porque, pero esto ahora es secundario. Voy a apresentar esto hoy(Martes) por la tarde. Voy a implementar su pdigo y qualquer cosa yo posto mi duda caso tenga.
Neeeeeeennnnnnnnnnnnnsssssssssssssseeeeeeeeeeeee!!!!!

Hola Paulao,
Soy de River y te agradecería que le ganen!:D
Bueno, al grano.

Tendría que ver como estás implementando el constructor para saber el error. No se si mi diseño es útil, yo hice ese bosquejo inicial para entrar en calor sobre el tema... Si es de práctica puede que sirva, por ello no me atreví a meterle código sin antes saber más o menos a que iba todo esto.

¿Hoy a la tarde?:confused::eek::o Va a ser dificil que me encuentres... yo estoy desvelado y me estoy durmiendo. Quisiera dormir un poquito, la verdad que no me esperaba que fuera tan pronto tu pedido.
Puede que mi diseño te sirva, y sabiendo que algunos ya están despiertos, y otros tantos están despertandose ayuda vas a encontrar.
No es que no quiera ayudarte, me encantaria... pero ya me caigo del sueño.
Te dejo en buenas manos.

Y si ves que se puede postergar la práctica... mejor.

Saludos,
PD: Espero que alguien más lea esto.