Versuche Objektorientierung zu lernen

[foerster7892]

Hi,

ich hab jetzt verschiedene Tutorials gelesen und verstehe meine Fehler trotzdem nicht könntet ihr mir vllt helfen?

unit 1:

Delphi-Quellcode:

unit Unit1; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unit2;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end; 

var
  Form1: TForm1; 
  Rechnen:TRechnen;
implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
begin
  Rechnen:=TAddition.create;
  Label1.caption:=FlaotToStr(Rechnen.calcit(StrToFloat(Edit1.Text), StrToFloat(Edit2.Text)));
  Rechnen.Destroy;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Rechnen:=TSubtraktion.create;
  Label1.caption:=FloatToStr(Rechnen.calcit(StrToFloat(Edit1.Text), StrToFloat(Edit2.Text)));
  Rechnen.Destroy;
end;

end.

unit2:

Delphi-Quellcode:

unit Unit2; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils;

type
  TRechnen=class(TObject)
    public
      constructor create;
      function calcit(a,b:real):real;virtual;
  end;

  TAddition=class(TRechnen);
    public
      constructor create;
      function calcit(a,b:real):real;override;
  end;

  TSubtraktion=class(TRechnen);
    public
      constructor create;
      function calcit(a,b:real):real;override;
  end;

var calcs:TRechnen;
implementation


  function TAddition.calcit(a,b:real):real;
  begin

    result:=a+b;
  end;

  function TSubtraktion.calcit(a,b:real):real;
  begin
    result:=a-b;
  end;

end.

Ja die Fehlermeldung ist denke ich egal(da sie auch nichts hilfreiches aussagt)

Ich möchte halt 2 Zahlen eingeben und dann als Ergebnis entweder den Summanden oder die Differenz bekommen. Das alles mit einer Klasse TRechnen welche weitervererbt wird an die Klassen TAddition und TSubtraktion.

Ich hoffe ihr könnt mir dies erklären.

Außerdem würde ich mich freuen wenn mir jemand nocheinmal mit eigenen Worten den Sinn von inhirated und die genaue Funktionsweise des constructors erklären könnte. (Den constructor braucht man irgendwie um Speicher für die klasse zu reservieren und sie zu erstellen, was bedeutet dies genau? Und inherited ka wird halt manchmal auch hingeschrieben und manchmal nicht...)

PS.: Ich benutze Lazarus falls es da irgendetwas spezielles zu beachten gibt.

[implementation]

Zitat von foerster7892:

Ja die Fehlermeldung ist denke ich egal(da sie auch nichts hilfreiches aussagt)

Oh doch, sie sagt eine Menge aus. Lass mich raten: Der Compiler findet die Implementierung von TRechnen.calcit nicht? Und alle drei Konstruktoren auch nicht?
Die Glaskugel sagt "Forward declaration not solved: ....".

Zitat:

Außerdem würde ich mich freuen wenn mir jemand nocheinmal mit eigenen Worten den Sinn von inhirated und die genaue Funktionsweise des constructors erklären könnte. (Den constructor braucht man irgendwie um Speicher für die klasse zu reservieren und sie zu erstellen, was bedeutet dies genau? Und inherited ka wird halt manchmal auch hingeschrieben und manchmal nicht...)

inherited bedeutet, dass die gleichnamige Methode der Elternklasse aufgerufen wird. Man kann hinter das inherited auch noch den Methodennamen und die Parameterliste schreiben, falls sich eines von beiden von der aktuellen Methode unterscheidet.

Zum Konstruktor: Es gibt im Speicher einen bestimmten Bereich, der sich "Heap" nennt. Alle Klasseninstanzen werden dort erstellt. Der Heapspeicher ist aber nicht sofort für die Anwendung verfügbar, sondern er muss ihr erst vom Betriebssystem zugewiesen werden. Auf unterster Ebene geht das mit malloc() und realloc(), aber das ist eine ganz schöne Frickelei. Der Konstruktor nimmt dir das ein bisschen ab und besorgt den Speicher für dich. Das tut er schon in der Basisklasse TObject, also wenn du immer brav inherited benutzt*, musst du dich darum nicht groß kümmern und kannst den Konstruktor allein dafür benutzen, die Felder zu initialisieren.

Zitat:

PS.: Ich benutze Lazarus falls es da irgendetwas spezielles zu beachten gibt.

In der Hinsicht eigentlich nicht. Es gibt ein paar Dialektunterschiede, aber die liegen woanders. Und die Fehlermeldungen lauten eben etwas anders als bei Delphi.


Oh und noch was: In Unit1 rufst du Rechnen.Destroy direkt auf. Tu das nicht! Jetzt im Moment geht das vielleicht noch gut, aber wenn die Programme mal komplexer werden, kann das schon eine potentielle Fehlerquelle werden. Nimm stattdessen Rechnen.Free!



*) Bei Konstruktor und Destruktor werden sie auch automatisch ergänzt, wenn sie fehlen, von daher nicht allzu schlimm, wenn man sie dort vergisst.

[foerster7892]

zur Fehlermeldung:
nein sie sagt: Unit2.pas(19,7) Fatal: Syntax error, "=" expected but "CONSTRUCTOR" found

So danke für die kurze Erklärung.

Nur nochmal zum Verständnis:
Wenn ich inherited benutze dann greife ich auf die Funktion der Mutterklasse zu also:

constructor TAddtion.create;
begin
inherited;
end;

jetzt würde ich also wenn ich:

Rechnen:=TAddition.create;
Rechnen.calcit(a,b);

und dies würde bei mir dann in der Mutterklasse landen und somit würde nichts passieren da diese ja in meinem Bsp. leer ist.

...und warum soll ich destroy nicht verwenden, in versch. Tutorials wurde Destroy verwendet in anderen free. Where is the difference?

...und wann muss ich überhaupt constructor create; schreiben und wann nicht und wo muss ich dass jeweils einfügen?

[implementation]

Zitat von foerster7892:

zur Fehlermeldung:
nein sie sagt: Unit2.pas(19,7) Fatal: Syntax error, "=" expected but "CONSTRUCTOR" found

Das kommt daher, dass du hinter class(TRechnen) beide Male ein Semikolon hast. Das heißt für den Compiler: "Hier ist der Typ zuende" - und daraufhin liest er 'public' und denkt, du willst noch einen weiteren Typen namens "public" deklarieren. Nimm die Semikola mal weg.

[Sir Rufo]

Zitat von implementation:

Zitat von foerster7892:

zur Fehlermeldung:
nein sie sagt: Unit2.pas(19,7) Fatal: Syntax error, "=" expected but "CONSTRUCTOR" found

Das kommt daher, dass du hinter class(TAddition) und class(TSubtraktion) Semikola hast. Das heißt für den Compiler: "Hier ist der Typ zuende" - und daraufhin liest er 'public' und denkt, du willst noch einen weiteren Typen namens "public" deklarieren. Nimm die Semikola mal weg.

Du meinst
TAddition=class(TRechnen); // <- das da und
TSubtraktion=class(TRechnen); // <- das da Des Weiteren finde ich noch

Delphi-Quellcode:

  Label1.caption := 
    FlaotToStr( // das heißt FloatToStr :o)
      Rechnen.calcit( 
        // 1. Parameter
        StrToFloat( // erwartet genau 1 Str-Parameter
          Edit1.Text, 
          Edit2.Text // wozu also der 2. Parameter hier ???
        )
        // 2. Parameter ... wo ist der ???
      )
    );

Aus diesen Gründen kommen bei mir auch immer sehr viele Leerzeichen in den Code - auch wenn der Styleguide diese verpönt - denn m.E. sieht man dann viel eher, dass da was nicht passt

Delphi-Quellcode:

...
Label1.Caption:=FloatToStr(Rechnen.CalcIt(StrToFloat(Edit1.Text, Edit2.Text)));
...
Label1.Caption := FloatToStr( Rechnen.CalcIt( StrToFloat( Edit1.Text, Edit2.Text ) ) );
...

[implementation]

Zitat von Sir Rufo:

Du meinst
TAddition=class(TRechnen); // <- das da und
TSubtraktion=class(TRechnen); // <- das da

Genau, danke für den Hinweis, ist korrigiert

[Sir Rufo]

Zitat von foerster7892:

Außerdem würde ich mich freuen wenn mir jemand nocheinmal mit eigenen Worten den Sinn von inhirated und die genaue Funktionsweise des constructors erklären könnte. (Den constructor braucht man irgendwie um Speicher für die klasse zu reservieren und sie zu erstellen, was bedeutet dies genau? Und inherited ka wird halt manchmal auch hingeschrieben und manchmal nicht...)

Jedes Objekt (TObject) hat von Haus aus einen constructor .
Dieser reserviert automatisch den Speicher.

Wenn du keine weiteren Anforderungen an dein Objekt hast, dann brauchst du auch keinen speziellen constructor .

Delphi-Quellcode:

type
  TFoo = class
    public
      procedure DoSomething;
  end;

...

procedure TFoo.DoSomething;
begin
  // some code
end;

Allerdings musst du alles, was du in der Typ-Deklaration angibst auch ausformulieren (Ausnahme bei virtual abstract )

inherited bedeutet, dass hier der Code aus der Ableitung ausgeführt werden soll.

Delphi-Quellcode:

type
  TFoo = class
    public
      InFooObject : TObject;
      constructor Create;
      destructor Destroy; override; // ist in TObject als virtual deklariert, darum override
  end;

...

constructor TFoo.Create;
begin
  inherited; // den Code der Vorgänger-Klasse - hier TObject.Create - ausführen
  
  InFooObject := TObject.Create;
end;

destructor TFoo.Destroy;
begin
  InFooObject.Free;

  inherited; // den Code aus der Vorgänger-Klasse - hier TObject.Destroy - ausführen
end;

Hier mal deine Unit2 korrekt formuliert:

Delphi-Quellcode:

unit Unit2; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils;

type
  TRechnen = class( TObject )
    public
      // virtual - weil diese Methode in der Regel überschrieben werden soll
      // abstract - weil es keine Basis-Implementierung gibt, eben halt abstrakt :o)
      function CalcIt( a, b : real ) : real; virtual; abstract;
  end;

  TAddition = class( TRechnen )
    public
      function CalcIt( a, b : real ) : real; override;
  end;

  TSubtraktion = class( TRechnen )
    public
      function CalcIt( a, b : real ) : real; override;
  end;

implementation

function TAddition.CalcIt( a, b : real ) : real;
  begin
    result := a + b;
  end;

function TSubtraktion.CalcIt( a, b : real ) : real;
  begin
    result := a - b;
  end;

end.

[foerster7892]

Wenn du keine weiteren Anforderungen an dein Objekt hast, dann brauchst du auch keinen speziellen constructor . // bedeutet? was sind "weitere Anforderungen?"

Ich zitier mich kurz mal selber, dass hatte ich vorhin noch hinzu editiert weil ich mir mit meinem Verständnis nicht sicher bin!

Zitat:

Nur nochmal zum Verständnis:
Wenn ich inherited benutze dann greife ich auf die Funktion der Mutterklasse zu also:

constructor TAddtion.create;
begin
inherited;
end;

jetzt würde ich also wenn ich:

Rechnen:=TAddition.create;
Rechnen.calcit(a,b);

und dies würde bei mir dann in der Mutterklasse landen und somit würde nichts passieren da diese ja in meinem Bsp. leer ist.

Achso und danke jetzt funzts. Aber warum trat bei constructor create Eintrag nen Fehler auf?

(sry dass ich euch gerade mit Fragen über Fragen bombardiere aber ich will dass bis Mitternacht durch haben soweit^^)

[Sir Rufo]

Zitat von foerster7892:

Wenn du keine weiteren Anforderungen an dein Objekt hast, dann brauchst du auch keinen speziellen constructor . // bedeutet? was sind "weitere Anforderungen?"

Wenn du in der Klasse noch einige Voreinstellungen vornehmen möchtest.

Delphi-Quellcode:

type
  TFoo = class
  private
    FData : integer;
  public
    constructor Create;
    property Data : integer read FData write FData;
  end;

...

constructor TFoo.Create;
begin
  inherited;

  // wir benötigen diesen constructor nur, weil wir FData mit dem Wert 10 initialisieren wollen
  FData := 10;
end;

Zitat von foerster7892:

Ich zitier mich kurz mal selber, dass hatte ich vorhin noch hinzu editiert weil ich mir mit meinem Verständnis nicht sicher bin!

Zitat:

Nur nochmal zum Verständnis:
Wenn ich inherited benutze dann greife ich auf die Funktion der Mutterklasse zu also:

constructor TAddtion.create;
begin
inherited;
end;

jetzt würde ich also wenn ich:

Rechnen:=TAddition.create;
Rechnen.calcit(a,b);

und dies würde bei mir dann in der Mutterklasse landen und somit würde nichts passieren da diese ja in meinem Bsp. leer ist.

Ja, und weil in dem constructor ja nichts passieren soll, dann kann man den auch gleich weglassen

Zitat von foerster7892:

Achso und danke jetzt funzts. Aber warum trat bei constructor create Eintrag nen Fehler auf?

Weil du in der Typ-Deklaration den constructor angegeben hattest, aber diesen nicht ausformuliert hast.

Delphi-Quellcode:

type
  TFoo = class
  public
    constructor Create;
    procedure DoSomething;
  end;

...

// Das hier fehlte bei dir !!!
constructor TFoo.Create;
begin
  inherited;

end;

procedure TFoo.DoSomething;
begin
  // some code
end;

Das meinte ich mit "Alles was du in der Typ-Deklaration angibst, musst du auch ausformulieren ...

Zitat von foerster7892:

(sry dass ich euch gerade mit Fragen über Fragen bombardiere aber ich will dass bis Mitternacht durch haben soweit^^)

Hast ja noch eine gute Stunde

[Popov]

Noch was zu constructor und inherited usw. Wenn du zum constructor nichts beizutragen hast, dann laß ihn weg, denn jede Klasse leitet sich von der Basisklasse TObject und erbt schon mal den constructor. Den hast du also schon. Dein

Delphi-Quellcode:

constructor TFoo.Create;
begin
  inherited;
end;

schadet zwar nicht, bringt aber auch nichts. Nötig wird es erst wenn du etwas dazu schreibst.

Nun zum inherited. So manches Mal stellt man sich die Frage ob er nötig ist, denn es gibt oft keinen Unterschied wenn man den wegläßt. Jetzt nicht hauen wenn es nicht stimmt, ist schon lange her wo ich es nach geguckt habe, aber bei Klassen auf der untersten Ebene ist nichts da was inherited aufrufen könnte. Deshalb könnte man sich die Frage stellen wozu der nötig ist. Nötig ist es spätestens da wenn man seine Klasse von einer anderen ableitet und die schon etwas in Create stehen hat. Dann, ohne inherited, wird der Part übergangen und die Klasse funktioniert nicht. Also am besten immer nutzen, ob nötig oder nicht. Dann geht es einem ins Blut über und man vergisst es nicht.