Interface richtig verstanden?

[TurboMagic]

Zitat von stahli:

"l" für lokal
Ich komme damit klar.

Das mag sein, aber hier muss ich mal doch Rudy zustimmen!
Man kann da sehr leicht was verwechseln...

[Schokohase]

Damit es auch jeder versteht:

Das Problem ist, dass Klein-Ludwig fast genauso aussieht wie Groß-Ida. Ja es ist abhängig vom Font.

Zitat:

l vs I

Zumal man im Allgemeinen in Delphi die PascalCase Schreibweise für Variablen-Namen bevorzugt und nicht wie z.B. bei C# camelCase. Und bei PascalCase wird der erste Buchstabe immer groß geschrieben.

Warum das jetzt wohl PascalCase heißt und wo das historisch herkommt darüber darf ein jeder still vor sich hin sinnieren.

Das Problem ist also nicht das L sondern nur die Schreibweise als Kleinbuchstabe.

[EdAdvokat]

Ich komme nochmals auf das Projekt von Stahli zurück.
TVogel hat das Interface IFlieg und die diesem eigene procedure Flieg.
TStorch wurde von TVogel abgeleitet. Also sollte doch auch TStorch, ebenso wie TAdler auch die das Interface IFlieg
besitzen, doch weder TStorch noch TAdler haben die von IFlieg verlangte procedure Flieg.
Bisher bin ich davon ausgegangen, dass die abgeleiteten Klassen (TStorch und TAdler) sowohl die Eigenschaften der
Basisklasse (TVogel) als auch das dem TVogel zugeordnete Interfache IFlieg ebenso wie das TInterfacedObject erben.
Hab ich das ganze noch nicht 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?

[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.

[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)