OOP--> Constructor richtig verwendet???

[Christian18]

Hallo,

ich bin gerade dabei mich so richtig intensiv mit OOP und Delphi zu beschäftigen. Ich habe mal versucht eine Klasse TNavi zu erzeugen. Die Klasse ist eine eigenständige klasse und wird nicht von einer anderen abgeleitet (vererbt)

dann habe ich noch einen constructor und eine Methode die einen button erzeugt. das funktioniert auch alles. meine frage ist jetzt nur, ob ich den construktor richtig verwendet habe??? ob ich seine eigentlich funktion richtig verwendet habe. Könnt ihr euch mal meinen code anschauen??? Für anregungen bin ich immer offen.

Hier mein Code:

Delphi-Quellcode:

unit UMain;

interface

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

type
  TFMain = class(TForm)
    procedure FormKeyDown(Sender: TObject; var Key: Word;
      Shift: TShiftState);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  FMain: TFMain;

implementation

{$R *.dfm}

procedure TFMain.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if shift=[] then begin
    case key of
      27 : Close;
    end;
  end;
end;

procedure TFMain.FormCreate(Sender: TObject);
  var n : TNavi;  // Menu
begin
  // Menu erzeugen
  n:=TNavi.Create(FMain, 'Button');
end;

end.

und hier die unit wo die klasse drinn ist.

Delphi-Quellcode:

unit UKlassen;

interface

uses
  Forms, StdCtrls;

type
  TNavi = class
    constructor Create(f : TForm; c : String);
    procedure Menu();
  private
    form : TForm;
    button : TButton;
    caption : String;
  public

  end;

implementation

constructor TNavi.Create(f : TForm; c : String);
begin
  form:=f;
  caption:=c;
  Menu();
end;

procedure TNavi.Menu();
begin
  button:=TButton.Create(nil);
  button.Caption:=caption;
  button.Top:=10;
  button.Left:=10;
  button.Parent:=form;
end;

end.

[Waldteufel]

Hi.

Sieht ganz gut aus, aber im Konstruktor musst du am Anfang noch

Delphi-Quellcode:

inherited;

schreiben, damit der Konstruktor von TObject aufgerufen wird. Ohne den gehts nicht.

[malo]

Du musst den Button und die Klasse noch zerstören, wenn du fertig bist ;) Das hast du vergessen.

[Christian18]

Zitat:

Zitat von malo

Du musst den Button und die Klasse noch zerstören, wenn du fertig bist ;) Das hast du vergessen.

so ???

Delphi-Quellcode:

procedure TNavi.Menu(); 
begin 
  button:=TButton.Create(nil); 
  button.Caption:=caption; 
  button.Top:=10; 
  button.Left:=10; 
  button.Parent:=form; 
  button.Free;
end;

wenn ich es so mache, dann wird der button nicht angezeigt.

[Christian18]

Zitat:

Zitat von Waldteufel

Hi.

Sieht ganz gut aus, aber im Konstruktor musst du am Anfang noch

Delphi-Quellcode:

inherited;

schreiben, damit der Konstruktor von TObject aufgerufen wird. Ohne den gehts nicht.

Hallo Waldteufel,

es funktioniert aber auch ohne inherited; ich kann keinen unterschied feststellen. also mit oder ohne --> kein unterschied.

mfg christian18

[jbg]

Zitat:

Zitat von Christian18

es funktioniert aber auch ohne inherited;

Aber auch nur, weil du implizit von TObject erbst und der TObject-Konstruktor leer ist. Unter .NET würde dir der Compiler einen Fehler ausgeben, weil er ein inherited benötigt.
Ich schreibe immer das inherited beim Konstruktor und Destruktor hin. Denn wenn ich oder ein Kollege mal die Basisklasse ändern sollte und dort z.B. einen eigene Konstruktor implementiert, ist man ganz schön auf der Suche nach dem Fehler.

[Christian18]

Was hat das mit den Constructor überhaupt für einen Sinn??? man kann es doch auch so machen.

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
  var n : TNavi;
begin
  n:=TNavi.Create();
  n.Erzeugen(Form1, 'Button');
  n.Free;
end;

end.

KLassen Unit:

Delphi-Quellcode:

unit Unit2;

interface

uses
  Forms, StdCtrls;

type
  TNavi = class
    procedure Erzeugen(f : TForm; c : String);
  private
    b : TButton;
  public

  end;

implementation

procedure TNavi.Erzeugen(f : TForm; c : String);
begin
  b:=TButton.Create(nil);
  b.Caption:=c;
  b.Top:=10;
  b.Left:=10;
  b.Parent:=f;
end;

end.

so funktioniert es auch und mache auch das gleiche. welche lösung ist besser??? warum???

[jbg]

Mit der "neuen" Lösung musst du jedem im Team erklären, dass er nach dem Create noch deine Erzeugen Methode aufrufen soll. Vergiss einer das, kannst du dir denken was passiert.

[Christian18]

Zitat:

Zitat von jbg

Mit der "neuen" Lösung musst du jedem im Team erklären, dass er nach dem Create noch deine Erzeugen Methode aufrufen
soll. Vergiss einer das, kannst du dir denken was passiert.

öhhhhhhhhmmmm... nichts?!?!?! :-D

[Christian18]

Kann mir jemand das Prinzip der Kapselung erklären??? Man findet den Begriff überall und ich habe keine Ahnung was das ist oder was man damit macht.

[Thorben77]

Sind zwar schon 'n paar neue Beiträge da, aber ich schick's trotzdem mal ab :???: .

Mach's so:

Überschreib den Destruktor und geb den Button da frei:

Delphi-Quellcode:

interface

type
  TNavi = class(TObject)
  private
    FButton: TButton;
  public
    constructor(AForm: TForm; ACaptuion: string);
    destructor Destroy; override;
  end;

implementation

constructor TNavi.Create(AForm: TForm; ACaptuion: string);
begin
  inherited Create;
  FButton := TButton.Create(nil);
  FButton.Caption := ACaption;
  FButton.Top := 10;
  FButton.Left := 10;
  FButton.Parent := AForm; 
end;

destructor TNavi.Destroy;
begin
  FButton.Free;
  inherited Destroy;
end;

Allerdings musst/solltest Du bei deinem Formular auch irgendwo Navi.Free aufrufen:

Delphi-Quellcode:

unit UMain;

interface

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

type
  TFMain = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    FNavi: TNavi;      // <--- hier ist das jetzt deklariert
  public
    { Public-Deklarationen }
  end;

var
  FMain: TFMain;

implementation

{$R *.dfm}

procedure TFMain.FormCreate(Sender: TObject);
begin
  // Menü erzeugen:
  FNavi := TNavi.Create(Self, 'BlaBlaBlubb');
end;

procedure TFMain.FormDestroy(Sender: TObject);
begin
  //  freigeben:
  FNavi.Free;
end;

end.

MfG

[Christian18]

Zitat:

Zitat von jbg

Mit der "neuen" Lösung musst du jedem im Team erklären, dass er nach dem Create noch deine Erzeugen Methode aufrufen soll. Vergiss einer das, kannst du dir denken was passiert.

Hallo jbg,

du hast geschriben, dann ich bei der zweiten Lösung anderen Programmierern sagen muß das man noch den Create noch die Methode aufrufen muß.

Ist das würklich so??? Ich habe mir einfach mal eine Delphi Standart Komponente angeschaut. (TOpenDialog) bei der ist es doch auch so wie in meiner zweiten Lösung oder sehe ich das falsch???

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
  var o : TOpenDialog;
begin
  o:=TOpenDialog.Create(self); --> erzeugen
  if o.Execute then --> aufruf durch Execut
    begin
      ...
    end;
end;

Ist das nicht das gleiche??? Also nochmal welche vorteile hat das ganze denn jetzt für mich wenn ich eine Constructor verwende???

MFG Christian18

PS: Meine Frage zu der Kapselung ist noch offen... :-D :-D :-D

[gfjs]

Hallo Christian18,

ich bin noch Anfänger, aber wenn ich das mit der Kapselung richtig verstanden habe, bedeutet es, dass die Daten durch die direkte Veränderung von außen "gekapselt" sind. D.h. die Variablen werden unter "private" deklariert und können dann nur durch Methoden des Objekts (z.B. SetXY) verändert werden.

Ich hoffe, ich liege da richtig.

mfg gfjs

[Christian18]

Zitat:

Zitat von gfjs

Hallo Christian18,

ich bin noch Anfänger, aber wenn ich das mit der Kapselung richtig verstanden habe, bedeutet es, dass die Daten durch die direkte Veränderung von außen "gekapselt" sind. D.h. die Variablen werden unter "private" deklariert und können dann nur durch Methoden des Objekts (z.B. SetXY) verändert werden.

Ich hoffe, ich liege da richtig.

mfg gfjs

also so wie ich mein erstes bsp. programmiert habe. oder???

[gfjs]

Hallo, Christian18.

Schaust Du hier: Delphi-Souce

mfg gfjs

[jbg]

Zitat:

Zitat von Christian18

Ist das nicht das gleiche???

Nein, denn dein "Erzeuge" gehört noch zum Initialisieren des Objekts. TOpenDialog.Execute setzt bereits eine vollständig initialisiertes TOpenDialog Instanz voraus.

Zitat:

Also nochmal welche vorteile hat das ganze denn jetzt für mich wenn ich eine Constructor verwende???

• Jeder versteht deinen Code besser.
• Du kannst die Vererbung nutzen.
• Du musst dir nicht bei jedem Objekt überlegen, ob da noch ein "Erzeuge" Aufruf hin muss.

Der Konstruktor heißt nicht um sonst Konstruktor. Er konstruiert das Objekt. Das war schon immer so und wird auch so bleiben. Das man das natürlich anders machen kann ist klar. Nur um den Konstruktor-Aufruf kommt man nicht herum und warum eine andere Programmierweise nutzen, wenn man sowieso den Konstruktor aufrufen muss.

[angos]

Zitat:

Zitat von Christian18

Zitat:

Zitat von jbg

Mit der "neuen" Lösung musst du jedem im Team erklären, dass er nach dem Create noch deine Erzeugen Methode aufrufen soll. Vergiss einer das, kannst du dir denken was passiert.

Hallo jbg,

du hast geschriben, dann ich bei der zweiten Lösung anderen Programmierern sagen muß das man noch den Create noch die Methode aufrufen muß.

Ist das würklich so??? Ich habe mir einfach mal eine Delphi Standart Komponente angeschaut. (TOpenDialog) bei der ist es doch auch so wie in meiner zweiten Lösung oder sehe ich das falsch???

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
  var o : TOpenDialog;
begin
  o:=TOpenDialog.Create(self); --> erzeugen
  if o.Execute then --> aufruf durch Execut
    begin
      ...
    end;
end;

Ist das nicht das gleiche??? Also nochmal welche vorteile hat das ganze denn jetzt für mich wenn ich eine Constructor verwende???

MFG Christian18

PS: Meine Frage zu der Kapselung ist noch offen... :-D :-D :-D

Hi Christian,

bei dem Beispiel wird der OpenDialog aufgerufen nicht erzeugt.

Deine beiden Sourcen machen genau das gleiche, aber:

du hast eine unit für die Komponente und eine Unit für dein Programm. Für jedesmal wenn du die Komponente nutzen möchtest (du kannst ja mehrere Instanzen erstellen) müsstest du folgendes Schreiben:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
  var n : TNavi;
begin
  n:=TNavi.Create();
  n.Erzeugen(Form1, 'Button');
  n.Free;
end;

Auch wenn du nun nur deine Komponente weitergeben möchtest müsste derjenige der sie nutzen möchte auch noch diesen Source selber schreiben. Dies kann man sich nun sparen, wenn man das einmal deklariert hat. Man hat dann nur noch den Einzeiler

Delphi-Quellcode:

n:=TNavi.Create(FMain, 'Button');

Gerade wenn man viele dieser Objekte hat, spart dies Zeit und ist übersichtlicher sowie weniger Fehleranfällig.

Hoffe geholfen zu haben

[Christian18]

Hallo,

ich habe hier nochmal ein drittest bsp. sollte man bei jeder klasse die man erzeugt einen constructor haben???

bsp.:

Delphi-Quellcode:

unit UKlassen;

interface

uses
  Forms, StdCtrls;

type
  TFenster = class
    constructor Create(Sender: TObject);
  private

  public

  end;

type
  TNavi = class
    constructor Create(f : TForm; c : Array of String);
    destructor Destroy();
  private
    b : TButton;   // Button für die Navigationsleiste
    w : TFenster;  // Fenster
  public

  end;

implementation

constructor TFenster.Create(Sender: TObject);
  var f : TForm;
begin
  f:=TForm.Create(nil);
  f.Caption:=TButton(Sender).Caption;
  f.ClientWidth:=240;
  f.ClientHeight:=320;
  f.BorderStyle:=bsSingle;
  f.BorderIcons:=[biSystemMenu,biMinimize];
  f.Font.Name:='Arial';
  f.KeyPreview:=True;
  f.Position:=poScreenCenter;
  f.ShowModal;
end;

constructor TNavi.Create(f : TForm; c : Array of String);
  var i : Integer;  // Schleifenvariable
begin
  for i:=0 to Length(c) - 1 do
    begin
      b:=TButton.Create(nil);
      b.Caption:=c[i];
      b.Width:=200;
      b.Height:=30;
      b.Top:=10 + i * 40;
      b.Left:=f.Width div 2 - b.Width div 2;
      b.OnClick:=TFenster.Create;
      b.Parent:=f;
    end;
end;

destructor TNavi.Destroy();
begin
  b.Destroy;
end;

end.

--> das bsp. funktioniert aber leider nicht. habe versucht den button ein onclik ereigniss zuzuweisen das ereigniss besteht aus den constructor. das kann man wohl nicht machen oder??? wie würdet ihr das denn machen, wenn das ereigniss in eine anderen klasse soll.

[jbg]

Wer war denn dein Delphi-Lehrer? Denn normalerweise kommt man auf sochen "Unsinn" nicht von alleine.

Ein Konstruktor kann nicht als Methodenzeiger verwendet werden. Und soeinen brauchst du für das OnClick. Du musst also eine TNotifyEvent kompatible Methode zu deiner Klasse hinzufügen und diese dann dem OnClick-Ereignis zuweisen.

[Christian18]

Zitat:

Zitat von jbg

Wer war denn dein Delphi-Lehrer? Denn normalerweise kommt man auf sochen "Unsinn" nicht von alleine.

Ein Konstruktor kann nicht als Methodenzeiger verwendet werden. Und soeinen brauchst du für das OnClick. Du musst also eine TNotifyEvent kompatible Methode zu deiner Klasse hinzufügen und diese dann dem OnClick-Ereignis zuweisen.

ja ich weiß, dann hat die klasse TFenster aber keinen constructor. ist das auch möglich das eine klasse keinen constructor hat???

mfg christian18

[jbg]

Zitat:

Zitat von Christian18

ist das auch möglich das eine klasse keinen constructor hat???

Jede Klasse hat einen Konstruktor und auch einen Destruktor. Und sei es er erbt ihn von TObject.