Interface richtig verstanden?

[Schokohase]

Wenn TVogel das Interface IFlieg implementiert, dann muss es dort auch alle Interface-Methoden geben.

Und wenn es diese gibt, dann sind die auch noch da, wenn ich von TVogel ableite. Das ist wie beim Vererben von Klassen, weil es Vererben von Klassen ist und hat mit Interfaces gar nichts zu tun.

[EdAdvokat]

Zitat von Schokohase:

Wenn TVogel das Interface IFlieg implementiert, dann muss es dort auch alle Interface-Methoden geben.

Und wenn es diese gibt, dann sind die auch noch da, wenn ich von TVogel ableite. Das ist wie beim Vererben von Klassen, weil es Vererben von Klassen ist und hat mit Interfaces gar nichts zu tun.

So ist auch mein Verständnis, jedoch die Tatsache, dass weder TAdler noch TStorch die der von IFlieg verlangten procedure Flieg haben, irritiert mich.Zusammengefasst: Warum läßt sich TAdler und TStorch ohne die procedure flieg erstellen? Wenn ich bei TVogel die procedure flieg auskommentiere, meckert der Compiler zu recht. Bei den abgeleiteten und mit allen Merkmalen der Vorfahren ausgestatteten TStorch und TAdler geht es ohne procedure flieg.

[Schokohase]

Wenn TVogel die Methode Flieg hat und leite von TVogel jetzt TStorch ab, dann erbt TStorch auch die Methode Flieg.

Das nennt man Vererbung!

Delphi-Quellcode:

TVogel = class
public
  procedure Flieg();
end;

TStorch = class(TVogel)
end;

procedure Foo();
var
  LStorch: TStorch;
begin
  LStorch := TStorch.Create();
  LStorch.Flieg(); // geht, weil von TVogel geerbt
end;

Du bist dir sicher, dass du ohne diese grundlegenden OOP Kenntnisse weiter in OOP mit Interfaces einsteigen willst?

[stahli]

Doch, das funktioniert auch.
Ersetze mal FormCreate (und die Unit u_Voegel musst Du natürlich noch einbinden).
Dann siehst Du, dass Storch.Flieg und auch IFlieg unterstützt wird.
Da musst Du irgend einen anderen Fehler drin haben.
Durch die Vererbung kennt die neue Klasse auch alles, was die Basisklasse kennt.
(Wenn man dann Methoden überschreiben will, muss man mit virtual und override arbeiten.)

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  R: IReader;
  S: ISchwimm;
  I: IInterface;
  //TList<ISchwimm>
  Storch: TStorch;
begin
  R := TXMLReader.Create;
  Read(R);
  R := TCSVReader.Create;
  Read(R);
//
//  S := TFactory.GetNewEnte;
//  S.Schwimm;
//  S := TFactory.GetNewBoot;
//  S.Schwimm;

  I := TFactory.GetNewEnte;
  if Supports(I, ISchwimm) then
    (I as ISchwimm).Schwimm;

  I := TFactory.GetNewAdler;
  if Supports(I, ISchwimm) then
    (I as ISchwimm).Schwimm;

  I := TFactory.GetNewEnte;
  if Supports(I, ISchwimm) then
    (I as ISchwimm).Schwimm;

  I := TFactory.GetNewAdler;
  if Supports(I, IFlieg) then
    (I as IFlieg).Flieg;

  I := TFactory.GetNewEnte;
  if Supports(I, IFlieg) then
    (I as IFlieg).Flieg;

  Storch := TStorch.Create;
  Storch.Flieg;
  if Supports(Storch, IFlieg) then
    ShowMessage('Flieg');

end;

Zusätzliche Anmerkung:

Etwas komplizierter wird es bei Vererbungen von Interfaces.
Wenn man ein InterfaceA hat und davon InterfaceB ableitet, und dann eine Klasse deklariert:
class TX(TInterfacedObject, InterfaceB),
dann liefert Supports(X, InterfaceA) false.

Um ein Supports zu ermöglichen, muss man das der Klasse AUSDRÜCKLICH zuweisen:
class TX(TInterfacedObject, InterfaceB, InterfaceA)

[EdAdvokat]

Delphi-Quellcode:

type

  TVogel = class(TInterfacedObject, IFlieg)
  private
  public
    procedure Flieg;
  end;

  TStorch = class(TVogel)
  private
    FSchnabellaenge: Integer;
    procedure SetSchnabellaenge(const Value: Integer);
  public
    property Schnabellaenge: Integer read FSchnabellaenge write SetSchnabellaenge;
  end;

  TAdler = class(TVogel)
  private
    FDioptrien: Integer;
    procedure SetDioptrien(const Value: Integer);
  public
    property Dioptrien: Integer read FDioptrien write SetDioptrien;
  end;

  TEnte = class(TVogel, ISchwimm)
  private
    FKalorien: Integer;
    procedure SetKalorien(const Value: Integer);
    procedure Schwimm;
  public
    property Kalorien: Integer read FKalorien write SetKalorien;
  end;

implementation

{ TStorch }

procedure TStorch.SetSchnabellaenge(const Value: Integer);
begin
  FSchnabellaenge := Value;
end;

{ TAdler }

procedure TAdler.SetDioptrien(const Value: Integer);
begin
  FDioptrien := Value;
end;

{ TEnte }

procedure TEnte.Schwimm;
begin

end;

procedure TEnte.SetKalorien(const Value: Integer);
begin

end;

{ TVogel }

procedure TVogel.Flieg;
begin

end;

end.

also weil ich die procedure Flieg bereits bei TVogel (ganz unten) erstellt habe, ist sie damit auch Bestandteil von TAdler und TStorch, ohne dass ich sie dort nochmals erstellen muss.

[Schokohase]

Das ist Vererbung und ist ein essentieller Teil von OOP

BTW Warum leitest du von TInterfacedObject ab? Weil du die dort implementierten Funktionen verwenden möchtest? Aber nach deinem Verständnis passiert das doch nicht.

[EdAdvokat]

ich denke doch dass ich die Vererbung in OOP verstehe. Doch die Forderung bei Interface stets die in der Interface-Dekleration aufgeführten Methoden in den Klassen, die
dieses Interface verwenden auch explizit aufzuführen, hat mich verwirrt.
Also da TVogel bereits die procedure flieg hat, kann ich TAdler und TStorch auch fliegen lassen, obwohl im vorliegenden Fall mit keinem Hinweis bei TAdler auf die procedure Flieg
eingegangen wird.
Entschuldigung für meinen gedanklichen Klemmer.

[stahli]

Kein Problem.
Kindklassen erben einfach auch Interfaces mit.

[EdAdvokat]

Stahli, Danke mit Deinem Beitrag #24 hast Du den konkreten Nachweis erbracht dass der Storch wirklich fliegt (showMessage('flieg').
Entschuldigung, es tut mir leid, euch genervt zu haben, doch manchmal hat man einen Klemmer.

[Rollo62]

Mit Interfaces kann man aber noch viel mehr Unsinn anstellen.
Weiterführende Beispiele z.B. hier.