Vererbung von Methoden verhindern

[.chicken]

Hi, ich habe ein Problem. Ich habe in meiner Basisklasse T2DXSprite zwei Methoden "Load" mit overload deklariert.
Jetzt brauche ich in der abgeleiteten Klasse T2DXAnimatedSprite auch genau zwei Methoden "Load", allerdings mir anderen Parametern. Ich möchte also verhindern, dass die alten Load Methoden angezeigt werden und möchte nur die neuen haben. Wie kann ich das erreichen?

Grüße

[mkinzler]

Indem du die Sichtbarkeit verringerst

[phXql]

Sollte man aber nicht machen. Verstecken von Methoden ist im OOP nich drin, da eine speziellere Klasse immer auch die Methoden der allgemeineren Klasse haben soll.

[SirThornberry]

sichtbarkeit verringern geht nicht da durch einen cast auf die vorgängerklasse wieder alle Methoden zur Verfügung stehen.

[.chicken]

Ja aber was soll ich denn dann machen? Die Load Methoden der alten Klassen sind ohne die neuen Parameter in der neuen Klasse sinnlos und können unter Umständen auch zu Fehlern führen, wenn sie statt den neuen Load-Methoden aufgerufen werden!? :gruebel: :wall:

[Phoenix]

Dann stimmt was an Deinem Klassendesign nicht.

Sauberste Idee: Du überdenkst Dein Klassendesign und sorgst dafür, dass das Verwenden einer Klasse auch dann noch funktioniert, wenn Du eine Ableitung dieser Klasse verwendest. Wenn man sich mal OOP zu herzen nimmt, dann muss man immer eine Ableitung der Klasse genauso benutzen können wie die Basisklasse, ohne das es zu Fehlern kommt.

Alternative (aber deutlichst schlechtere) Lösung:
Du überschreibst die beiden alten Methoden und anstelle was zu machen wirfst Du ne Exception.

[SirThornberry]

eine andere Variante wäre noch die alten Methoden zu überschreiben und daraus die neuen Methoden mit Standardparamtern aufrufen.

[BUG]

Vielleicht wäre es dan besser, T2DXAnimatedSprite nicht von T2DXSprite abzuleiten, sondern beide einer abstrakte Basisklasse abzuleiten, in der bereits alle Methode und Eigenschaften deklariert werden, die die beiden abgeleiteten Klassen gemeinsam haben.

MfG,
Bug

[.chicken]

Hm, ok ich überdenke das nochmal ;-)
Danke

[Jelly]

Also wenn ich folgendes deklariere:

Delphi-Quellcode:

TSprite = class
    public
       procedure Load; overload;
       procedure Load(i : integer) ; overload;
end;

TSprite2 = class(TSprite)
    public
      procedure Load(i, j : integer) ;
end;

dann erhält man Folgendes Verhalten:

Delphi-Quellcode:

procedure TForm2.cmd1Click(Sender: TObject);
var
   sprite : TSprite2;
begin
      sprite := TSprite2.Create;
      sprite.Load(1, 2) ;            // Es steht nur die Load Methode aus TSprite2 zur Verfüung
end;

bzw.

Delphi-Quellcode:

procedure TForm2.cmd1Click(Sender: TObject);
var
   sprite : TSprite;
begin
      sprite := TSprite2.Create;
      sprite.Load(1) ;            // Es stehen die Load Methode aus TSprite zur Verfüung
end;

Also was stört dich an diesem Verhalten...
Wenn du unbedingt willst, dass die Load Methode NUR DANN auch ausgeführt werden, wenn du direkt eine Instanz über TSprite.Create erstellst, dann kannst du das höchstens zur Laufzeit in der Load Methode selbst prüfen, z.B. so:

Delphi-Quellcode:

procedure TSprite.Load;
begin
     if (Self.ClassNameIs('TSprite')) then
    begin
        showmessage('No param') ;
    end;
end;

procedure TSprite.Load(i: integer);
begin
    if (Self.ClassNameIs('TSprite')) then
    begin
        showmessage(inttostr(i)) ;
    end;
end;

Aber schön ist das nicht, weil es, wie es von Jens und Sebastian bereits angedeutet wurde, nicht im Sinne der Objektorientierung ist.