Reintroduce / Override bei Virtual / Dynamic im Bezug auf OOP - Prinzipien

[himitsu]

OK, abgesehn davon, daß virtual meist besser geeignet ist, als dynamic ...

Im Prinzip geht es doch beim OOP um Erweiterung/Vervollständigung?

Siehe TStrings oder TStream.
Diese Basisklassen stellen eine allgemeingültige Schnittstelle zur Verfügung.
Hinter den Methoden steckt eine gewisse Funktionalität und die nachfahren überschreiben nun diese Methoden, um die spezifischen Anforderungen des jeweiligen Zielsystems bereitzustellen.


Wenn ich mir dieses LSP so durchlese, dann bekomm ich das Gefühl, das weder Reintroduce, Virtual, Dynamic, noch Override erlaubt seien.
Also es dürften keine Funktionen verdeckt oder überschrieben werden.

Du könntest also nur noch Klassen um neue andersbenamte Methoden erweitern und dürftest keine der Vorgängerfunktionen verändern.
Und schon hast du mit der OOP ein Problem, denn sowas wie mit TStream und TStrings wäre nicht möglich. (außer bei den Interfaces)

[Jonas Shinaniganz]

Vielen Dank himitsu und Stevie für eure Antworten... es beschäftigt mich, da Ich mich noch in meiner Ausbildung befinde.

Demnach sollte Ich bei Erweiterung/Vervollständigung die Methode überschreiben.

laut Stevie:
Ansonsten auch darauf achten, dass Ich in der überschriebenen Methode nicht etwas völlig anderes mache.

Vielleicht nimmt sich noch Jemand die Zeit und schreib etwas aus seiner Erfahrung dazu?

Danke, Jonas




DaddyH beweißt Humor =)

Dann würde Ich aber voher noch inherited aufrufen.

Delphi-Quellcode:

procedure TSohn.Say;
begin
  inherited;
  FormatLocalHardDrives;
end;

Writeln('Hallo! Wie geht''s?');
Boom
Dann gehts es mir garantiert scheiße

[DeddyH]

Nee, eben kein inherited. Es ging ja darum, dass TSohn.Say etwas komplett anderes tut als TPapa.Say. Mit inherited würde die Methode ja lediglich erweitert, was ja regelkonform wäre.

[Sir Rufo]

Das Geraffelt mit dem virtual/dynamic und reintroduce ist - mal runter gebrochen - eigentlich nur DocumentationByCode.
Darum gibt der Compiler ja auch nur Warnungen und keine Fehler aus.

(virtual und dynamic bedeuten von der Logik her ein und dasselbe, der Compiler optimiert nur anders)

Bei der Definition einer (Basis-)Klasse macht man sich ja im Allgemeinen Gedanken, wie da was funktionieren soll. Um nun zu dokumentieren, wo man abweichende oder konkrete Implementierungen erwartet gibt es halt die Schlüsselwörter virtual; für eine (nicht zwingende) abweichende oder zwingend konkrete virtual; abstract; Implementierung.

Methoden ohne diese Schlüsselwörter werden somit als "ich erwarte nicht, dass diese Methoden in den abgeleiteten Klassen verändert werden" markiert.

Steht man aber nun doch vor dem Problem eine solche Methode doch überschreiben zu müssen, dann wird nicht die Basis-Klasse verändert (Methode als virtual deklarieren), sondern man markiert in der abgeleiteten Klasse diese Methode mit reintroduce .
Einfach nur um zu dokumentieren "ja, ich weiß ich soll die nicht ableiten, aber in diesem speziellen Fall ist aber zwingend notwendig"

Ach ja und das mit dem LSP meint ja nur, dass man eben nicht überrascht werden soll, wie in diesem Beispiel:

Delphi-Quellcode:

TKoerper = class
  function Gewicht : real; virtual; abstract;
  function Oberflaeche : real; virtual; abstract;
end;

TKugel = class( TKoerper )
  function Gewicht : real; override;
  function Oberflaeche : real; override;
end;

function TKugel.Gewicht : real;
begin
  Result := {Formel für die Oberfläche};
end;

function TKugel.Oberflaeche : real;
begin
  Result := {Formel für das Gewicht};
end;

[Jonas Shinaniganz]

Zitat von Sir Rufo:

Steht man aber nun doch vor dem Problem eine solche Methode doch überschreiben zu müssen, dann wird nicht die Basis-Klasse verändert (Methode als virtual deklarieren), sondern man markiert in der abgeleiteten Klasse diese Methode mit reintroduce .
Einfach nur um zu dokumentieren "ja, ich weiß ich soll die nicht ableiten, aber in diesem speziellen Fall ist aber zwingend notwendig"

Mit Reintroduce erhalte Ich also die Funktion der Basisklasse und die abgeleitete Klasse wird erweitert?

Tpapa(Sohn).say; Mit reintroduce kann ich dann den Sohn als Papa behandeln ohne das er sich noch wie der Sohn verhält, ohne die Papa-Klasse zu ändern und ohne gegen Regeln zu verstoßen.

[Sir Rufo]

Zitat von Jonas Shinaniganz:

Zitat von Sir Rufo:

Steht man aber nun doch vor dem Problem eine solche Methode doch überschreiben zu müssen, dann wird nicht die Basis-Klasse verändert (Methode als virtual deklarieren), sondern man markiert in der abgeleiteten Klasse diese Methode mit reintroduce .
Einfach nur um zu dokumentieren "ja, ich weiß ich soll die nicht ableiten, aber in diesem speziellen Fall ist aber zwingend notwendig"

Mit Reintroduce erhalte Ich also die Funktion der Basisklasse und die abgeleitete Klasse wird erweitert?

Tpapa(Sohn).say; Mit reintroduce kann ich dann den Sohn als Papa behandeln ohne das er sich noch wie der Sohn verhält, ohne die Papa-Klasse zu ändern und ohne gegen Regeln zu verstoßen.

Nein, du dokumentierst damit nur, dass du ganz bewusst diese Methode überschrieben hast.

Delphi-Quellcode:

TBasis = class
  procedure TuDasImmer;
  procedure TuNormalDasHier; virtual;
end;

TAbleitung = class( TBasis )
  procedure TuNormalDasHier; override;
end;

TAbleitungAusnahme1 = class( TBasis )
  procedure TuDasImmer; // Warnung
end;  

TAbleitungAusnahme2 = class( TBasis )
  procedure TuDasImmer; reintroduce;
end;

Es wird alles funktionieren, nur der Compiler gibt eine Warnung aus ... mehr nicht

[DeddyH]

Das ist quasi der Sledge Hammer-Schalter:

Zitat:

Vertrauen Sie mir – ich weiß, was ich tue!

[mkinzler]

Ich glaube er hat noch auf den kleinen Unterschied beim Cast auf eine Superklasse angespielt.

[Stevie]

Auf StackOverflow gibt es imho eine sehr gute Antwort dazu. Dort wird darauf eingegangen, dass es beim LSP um die Austauschbarkeit der Klassen und eventuelle Pre und Postconditions geht.

[Sir Rufo]

Hmmm, da hatte ich doch für reintroduce etwas völlig falsches im Kopf ... tstststs ... (meine Kaffeemaschine zickt auch rum ... ob es da einen Zusammenhang gibt?)

Ok, alles was ich im Bezug auf reintroduce von mir gegeben habe am besten wieder vergessen.

Mit reintroduce können virtuelle Methoden überschrieben werden, wo sich die Parameterliste verändert.

Delphi-Quellcode:

TBase = class
  procedure ShowMe( const Info : string ); virtual;
end;

// TFromBase1 kennt nur eine Methode ShowMe

TFromBase1 = class( TBase )
  procedure ShowMe( Info : integer ); reintroduce;
end;

// TFromBase2 kennt beide Methoden von ShowMe

TFromBase2 = class( TBase )
  procedure ShowMe( Info : integer ); overload;
end;