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

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

[himitsu]

Da wird nichts überschrieben. Es schaltet nur die Wanung ab, wenn man etwas absichtlich "verdecken" (nicht "überschreiben") will.

Und das "Verdecken" bezieht sich nur auf den Namen und nicht auf die Parameter.

Mit Overload gibt man an, daß man etwas Gleichnamiges, aber mit anderer Parametersignatur, "überladen" will.
Alle Methoden existieren gleichzeitig innerhalb der selben Klasse, bzw. auf alle ist zugreifbar.

Override "überschreibt" quasi die "Links", welche von Virtual oder Dynamic erstellt wurden.

[DeddyH]

http://docwiki.embarcadero.com/RADSt...en#Reintroduce:

Zitat:

Reintroduce

Die Direktive reintroduce unterdrückt Compiler-Warnungen, wenn zuvor deklarierte virtuelle Methoden verdeckt werden. Zum Beispiel:

Delphi-Quellcode:

procedure DoSomething; reintroduce; // In der Vorfahrklasse ist ebenfalls 
                                    // eine DoSomething-Methode vorhanden

Verwenden Sie reintroduce, wenn eine geerbte virtuelle Methode durch eine neue Deklaration verdeckt werden soll.

[Jonas Shinaniganz]

Frisch aus dem Mittagspäuschen!

Also ich fasse zusammen:
"virtual" : speed optimiert
"dynamic" : memory optimiert

beide ermöglichen in einer vererbten Klasse override zu benutzen. Wobei virtual das zu bevorzugende Schlüsselwort ist.

"abstract" : Methode sollte in der vererbten Klasse implementiert werden wenn man sie benutzen will.

"overload" : hat damit erstmal nichts zu tun, sondern ermöglicht Methoden den gleichen Namen zu geben und durch die unterschiedlichen Signaturen der Methoden unterschiedliche Parameter zu empfangen und immer anders zu verarbeiten.

"reintroduce" : Eine geerbte virtuelle Methode durch eine neue Deklaration verdecken. Wird die vererbte Klasse als die Basisklasse behandelt am Beispiel (TPapa(Sohn)) würde die Methode say von Tpapa aufgerufen werden, beim weglassen von "reintroduce" ist es eigentlich genauso, allerdings mit Warnung, welche ja berechtigt ist weil vielleicht Tpapa's Methode Abtract war und nicht existiert, Stichwort: AbstractError

"override" : Verweißt auf die Methode der Vererbten Klasse, sodass immer diese aufgerufen wird und nicht die virtuelle methode der Elternklasse welche ja vielleicht abstract ist und dann nicht existiert und das aufrufen zu einem Fehler führen würde.

Delphi-Quellcode:

program Override_Reintroduce_Unterschied;


{$APPTYPE CONSOLE}


uses
  SysUtils;


type
  Tpapa = class
  public
    { public declarations }
    procedure say; virtual; abstract;
  end;


  Tsohn = class(Tpapa)
  public
    { public declarations }
    procedure say; override;
  end;


var
  Sohn : Tsohn;


procedure Tsohn.say;
begin
  Writeln('Hi!');
end;


begin
  try
    Sohn := TSohn.Create;
    TPapa(Sohn).say;


    ReadLn;
    { TODO -oUser -cConsole Main : Code hier einfügen }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;


end.

Ich habe das Gefühl es ein wenig verstanden zu haben.

Thumbs Up

[Jonas Shinaniganz]

Angenommen Ich habe eine Klassenmethode mit Virtual; kenntlich gemacht und erwarte das diese überdeckt werden soll. (Das ist ja die Bedeutung von Virtual Wieso brauche Ich dann ein Reintroduce in der Vererbten Klasse um eine Warnung zu unterdrücken? Ich müsste doch glücklich sein, wenn jemand meine Klassenmethode verbirgt...

Verborgen wird sie doch auch wenn Ich kein Virtual in der Elternklasse habe und kein Reintroduce in der vererbten Klasse.

Das Gleiche Resultat habe ich auch wenn ich einfach nur in der vererbten Klasse Reintroduce einsetze ohne, dass in der Elternklasse etwas davon stand.


Der einzige Sinn des Ganzen ist doch nur der, dass falls jemand meinte, das seine Methode in vererbten Klassen überschrieben werden sollte, ein virtual; verbaut.

Und damit der, der die Erbung macht, sozusagen: "Ja, ist angekommen", zu verstehen geben kann, ein Reintroduce anhängt.

Und der Compiler spielt hierbei die Rolle der Vermittelnden Person zwischen den beiden Programmierern. Quasi eine Compiler SMS

Gut, jetzt weiß Ich wie der Hase läuft.