liege ich richtig mit dem OOP-Versuch

[Der schöne Günther]

Zitat von Luckie:

Wozu der Zähler? Wenn jemand mehrere Flächen berechnen will, dann soll er das selbst implementieren.

Ich glaube das klassische Beispiel für Klassenvariablen. Klar kann man sich über den Sinn streiten, aber ich finde das als Beispiel ganz gut.

[SProske]

Zitat von Luckie:

Delphi-Quellcode:

  public
    Property Laenge: Double write SetLaenge;
    Property Breite: Double write SetBreite;
    Property Flaeche: Double read FFlaeche;

Wieso Länge und Breite als write only?
Und müsste die Property Flaeche nicht als read-procedure das BerechneFlaeche bekommen?

Zitat von Luckie:

Delphi-Quellcode:

  
  procedure TRechteck.SetLaenge(laenge: double);
  begin
    // ToDo:
   // wenn kleiner 0 -> Exception auslösen "Länge darf nicht kleiner 0 sein"
   // oder besser allgemeine Exception InvalideArgument
   laenge := FLaenge;
  end;

Sollte die Zuweisung nicht genau andersherum erfolgen?
Ist es eine gute Idee, den Parameter der Set-Procdure genau so zu nennen, wie die Property - irgendwann fängt man dann doch an zu überlegen, was von beiden eigentlich grad angesprochen wird.

[EWeiss]

Zitat:

Sollte die Zuweisung nicht genau andersherum erfolgen?

nein.. sorry da nur schreibzugriff
ja war quatsch von mir

gruss

[Luckie]

Ja natürlich andersherum. Sie heißen doch unterschiedlich.

Zitat:

Wieso Länge und Breite als write only?

OK, kann man drüber streiten, ob die Klasse auch die Eingabewerte wieder zurückgeben können soll. Weil die weiß ich ja, sonst hätte ich die Klasse ja gar nicht nutzen können.

Zitat:

Und müsste die Property Flaeche nicht als read-procedure das BerechneFlaeche bekommen?

Nein. Die private Prozedur zum Berechnen der Fläche legt das Ergebnis in FFlaeche ab.

[SProske]

Zitat von Luckie:

Ja natürlich andersherum. Sie heißen doch unterschiedlich.

Laenge und laenge sind für mich nicht unterschiedlich - zumindest mein Delphi ist in der Hinsicht nicht case-sensitiv.

Zitat von Luckie:

OK, kann man drüber streiten, ob die Klasse auch die Eingabewerte wieder zurückgeben können soll. Weil die weiß ich ja, sonst hätte ich die Klasse ja gar nicht nutzen können.

Naja, zwischen dem zuweisen der Werte und dem Zeitpunkt, wo ich gern wieder Zugriff drauf hätte, kann aber noch eine halbe bis ganze Weltreise liegen. Spätestens wenn ich mehrere Dreiecke in eine Liste stecke und diese nach der Länge sortieren will, wäre es schon cool auf die Länge auch zugreifen zu können.

Zitat von Luckie:

Nein. Die private Prozedur zum Berechnen der Fläche legt das Ergebnis in FFlaeche ab.

Und wo wird die aufgerufen? :>

[Luckie]

Unterschiedliche Namen:

Delphi-Quellcode:

 procedure TRechteck.SetLaenge(laenge: double);
  begin
    // ToDo:
   // wenn kleiner 0 -> Exception auslösen "Länge darf nicht kleiner 0 sein"
   // oder besser allgemeine Exception InvalideArgument
   FLaenge := laenge;
  end;

Der Parameter heißt laenge das Attribut FLaenge.

Delphi-Quellcode:

  procedure TRechteck.BerechneFlaeche;
  begin
    FFlaeche := FLaenge * FBreite;
  end;
  
  
  // Aufruf im Formular
  Flaeche := Rechteck.Flaeche;

Flaeche ist die private variable und Rechteck.Flaeche ist das Attribut Flaeche des Objektes Rechteck. Nix gleich.

Wie gesagt, man kann drüber streiten. Aber wenn du eine gescheite Datenhaltung machst, sollte es kein Problem sein an die Werte zu kommen. Wie gesagt, du musst sie ja selber wissen, wenn du die Klasse nutzen willst.


PS: War alles nur ins Notepad++ gehackt. Ich übernehme keine Gewähr für nichts.

[SProske]

Zitat von Luckie:

Der Parameter heißt laenge das Attribut FLaenge.

Die Property heißt Laenge, der Parameter laenge - ich habe nie von dem Attribut gesprochen. Und da auch im Getter/Setter einer Property auf diese zugegriffen werden kann, sehe ich da schon Potential für Verwirrung.

Zitat von Luckie:

Delphi-Quellcode:

  procedure TRechteck.BerechneFlaeche;
  begin
    FFlaeche := FLaenge * FBreite;
  end;
  
  
  // Aufruf im Formular
  Flaeche := Rechteck.Flaeche;

Aber wo wird denn jemals die private Methode procedure BerechneFlaeche: Double; aufgerufen? In den Settern nicht, als Read-Methode der Property nicht und von außerhalb kommt man da nicht dran (okay, das ist gelogen - in der selben Unit schon - aber das wäre ja echt doof, wenn ich die Klasse nur innerhalb dieser Unit sinnvoll verwenden kann)

Zitat von Luckie:

Wie gesagt, man kann drüber streiten. Aber wenn du eine gescheite Datenhaltung machst, sollte es kein Problem sein an die Werte zu kommen. Wie gesagt, du musst sie ja selber wissen, wenn du die Klasse nutzen willst.

Im einfachst konstruierten Fall lese ich die Länge/Breite aus einer Datenbank aus und möchte sie dann, zusammen mit dem berechneten Fläche in einem Formular anzeigen - das ganze natürlich nicht nur für ein Rechteck, sondern für viele. Ich bräuchte dann also eine Rechteck-Klasse, die Breite und Länge als Read/Write-Property hält und eine, die Breite und Länge als Write-Only-Property hält und die Fläche berechnet?

Ich hätte das ganze dann doch eher folgend aufgebaut:

Delphi-Quellcode:

  TRechteck = class
  strict private
    FLaenge: Double;
    FBreite: Double;
    function GetFlaeche: Double;
    function GetUmfang: Double;
    procedure SetLaenge(const Value: Double);
    procedure SetBreite(const Value: Double);
  public
    property Laenge: Double read FLaenge write SetLaenge;
    property Breite: Double read FBreite write SetBreite;
    property Flaeche: Double read GetFlaeche;
    property Umfang: Double read GetUmfang;
  end

[Luckie]

Zitat von SProske:

Zitat von Luckie:

Delphi-Quellcode:

  procedure TRechteck.BerechneFlaeche;
  begin
    FFlaeche := FLaenge * FBreite;
  end;
  
  
  // Aufruf im Formular
  Flaeche := Rechteck.Flaeche;

Aber wo wird denn jemals die private Methode procedure BerechneFlaeche: Double; aufgerufen? In den Settern nicht, als Read-Methode der Property nicht und von außerhalb kommt man da nicht dran

Ah. Jetzt sehe ich, was du meinst. Öhm ja. Notepad++ eben. Da müsste man noch was machen. Bisschen Voodoo oder so.

[EdAdvokat]

Hallo, ich habe versucht, die Lösung von Sebastian (SProske) umzusetzen. Eine Unit Formuar und eine unit TFlaecheninhalt.
Ich komme einfach nicht mit den Werteeingaben weiter. Die Variablen L und B erhalten zwar die eingegebenen Werte, jedoch
Flaecheninh.Laenge und Flaecheninh.Breite bleiben auf 0 entspr. der Initialierung. Was mache ich da falsch und ist die
Umsetzung (natürlich ohne die variablen l und b im Formular) sonst richtig?


--------------------------------------------unit TForm1-----------------------------------------------------------
.....implementation

{$R *.dfm}

procedure TForm1.BerechneFlClick(Sender: TObject);
var L, B : double;
begin
try
l:= strtofloat(laenge.Text);
B:= strtofloat(Breite.Text);
Flaecheninh.Laenge:=L;
Flaecheninh.Breite:=B;
//Flaecheninh.Laenge:=strtofloat(Laenge.Text);
//Flaecheninh.Breite:=(strtofloat(Breite.text));
LbFlaecheninhalt.Caption:=floattostr(Flaecheninh.F laeche);
except
l:=(5);
b:=(4);
end;
end;
{------------------------------------------------------------------------------}
procedure TForm1.BitBtn1Click(Sender: TObject);
begin
close;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
lbUmfang.Caption:=floattostr(Flaecheninh.Umfang);
end;

{------------------------------------------------------------------------------}
procedure TForm1.FormCreate(Sender: TObject);
begin
Flaecheninh := TFlaecheninh.create;
Flaecheninh.init;
end;
{------------------------------------------------------------------------------}
procedure TForm1.init;
begin
Laenge.Text:='0';
Breite.Text:='0';
lbFlaecheninhalt.Caption:='0';
end;
end.
------------------------------------------------------------------------------------------------------------------
--------------------------------------------unit TFlaecheninh-----------------------------------------------------

interface

type
TFlaecheninh = class
strict private
FLaenge: Double;
FBreite: Double;
function GetFlaeche: Double;
function GetUmfang: Double;
procedure SetLaenge(const Value: Double);
procedure SetBreite(const Value: Double);
public
constructor create;
destructor Destroy; override;
procedure init;
property Laenge: Double read FLaenge write SetLaenge;
property Breite: Double read FBreite write SetBreite;
property Flaeche: Double read GetFlaeche;
property Umfang: Double read GetUmfang;
end;

implementation

constructor TFlaecheninh.create;
begin
inherited create;
init;
end;
{------------------------------------------------------------------------------}
destructor TFlaecheninh.Destroy;
begin
inherited Destroy;
end;
{------------------------------------------------------------------------------}
procedure TFlaecheninh.init;
begin
FLaenge:=0.0;
Breite:=0.0;
end;
{------------------------------------------------------------------------------}
function TFlaecheninh.getFlaeche: double;
begin
result:=FLaenge * FBreite;
end;
{------------------------------------------------------------------------------}
procedure TFlaecheninh.setLaenge(const value:double);
begin
FLaenge:= Laenge;
end;
{------------------------------------------------------------------------------}
procedure TFlaecheninh.setBreite(const value:double);
begin
FBreite:= Breite;
end;
{------------------------------------------------------------------------------}
function TFlaecheninh.GetUmfang:double;
begin
result:=2*FLaenge+2*FBreite;
end;
end.

[Der schöne Günther]

Tipp: Schau dir deine beiden Methoden setLaenge und setBreite noch einmal ganz genau an.


PS: Kannst du, wenn du Quelltext hier hochlädst, die bitte in einen "Delphi"-Block packen? Dann sind die viel einfacher zu lesen. Du hast, wenn du einen Beitrag schreibst, so ein Helm-Symbol über dem Text (siehe Bild). Dann ist das für uns deutlich einfacher zu lesen.