Methoden - "Vererbung"

[Neutral General]

Hi,

Also man kann ja einfach Methoden überschreiben etc...
Bin mir eigentlich recht sicher, dass das was ich vorhabe NICHT geht aber ich frage nochmal nach obs da irgendwas gibt, bzw ob man da was basteln/improvisieren könnte...

Angenommen ich habe eine Klasse mit einer Methode "Auto" und eine Nachfolgerklasse hat die Methoden "VW", "Audi", "BMW" und "Mercedes". Alle Methoden sollen quasi von "Auto" erben, also es soll bei jeder Methode am Anfang der Code von "Auto" ausgeführt werden. Geht das? Naja gut es ginge so:

Delphi-Quellcode:

TAuto = class
  procedure Test; virtual;
end;

TAuto2 = class(TAuto)
  procedure VW; 
  procedure Audi;
end;

procedure TAuto2.VW;
begin
  inherited Test;
end;

procedure TAuto2.Audi;
begin
  inherited Test;
end;

Aber das ist irgendwie nicht was ich suche...
Ja ich weiß.. Blöd wenn man selbst nicht weiß was man sucht/will

Aber vielleicht hat jmd eine besonders gute Glaskugel und kann mir trotzdem helfen

Edit: Ich will quasi dass inherited Test automatisch aufgerufen wird, ohne dass in der Methode selbst nochmal aufrufen zu müssen.

Sagen wir mal sowas wie:

Delphi-Quellcode:

TAuto2 = class(TAuto)
  procedure VW; inherits from Test;  
  procedure Audi; inherits from Test; 
end;

Gruß
Neutral General

[Medium]

Du kommst echt immer auf seltsame Ideen

Ich kann mir erstmal nicht vorstellen dass sich sowas hinbügeln lässt - zumindest nicht im Rahmen reiner theoretischer OOP - aber auch mit Tricksen und Hacksen kann ich mir im Moment nicht wirklich was vorstellen.

[sx2008]

Glasskugel dreh...du sucht das Strategie Design Pattern.

[Neutral General]

Zitat von sx2008:

Glasskugel dreh...du sucht das Strategie Design Pattern.

Ist das nicht einfach nur Polymorphie?

Ich will ja sowas:

Delphi-Quellcode:

TBase = class
  procedure BaseProc;
end;

TAbleitung = class(TBase)
   procedure Blubb; of BaseProc;  // oder so :-D
   procedure Foo; of BaseProc;
end;

procedure TBase.BaseProc;
begin
  ShowMessage('Base');
end;

procedure TAbleitung.Blubb;
begin
  ShowMessage('Blubb');
end;

procedure TAbleitung.Foo;
begin
  ShowMessage('Foo');
end;

Jetzt soll wenn man TAbleitung.Blubb; aufruft erst BaseProc aufgerufen werden und dann Blubb selbst.
Bei procedure TAbleitung.Foo das gleiche Prinzip. Erst BaseProc, dann Foo.

[Namenloser]

Du wirst wohl um ein inherited nicht herumkommen. Wozu auch? Ist doch viel sinnvoller, wenn du bestimmen kannst, WANN die Methode aufgerufen werden soll. Oft ist es ja nötig, vor dem Aufruf noch Daten zu verändern oder anschließend aufzuräumen.

Eventuell wäre es gut, wenn du mal erläutern könntest, was du eigentlich konkret vorhast.

[Neutral General]

Hi,

Generell hast du recht.. Naja es geht um das gleiche Problem, was ich schonmal hier auf eine andere Weise lösen wollte.
Es geht darum Änderungen von Properties eines Objekts mitzubekommen und darauf reagieren zu können.

Bedingungen:
- es muss eine Set-Methode für die jeweilige Property existieren
- ... Wobei es genial wäre, wenn nichtmal das nötig wäre
- Der Nutzer dieses Features soll seine eigene Klasse möglichst wenig anpassen müssen.
D.h. er bestimmt, dass seine Klasse TFoo überwacht werden soll und muss dazu IM IDEALFALL nichts an TFoo ändern/anpassen.
1 oder 2 kleine Änderungen wären noch OK.

Aber es wäre halt nervig wenn er in jede Set-Methode daran denken müsste inherited BlaBla; aufzurufen. Wenn ers vergisst, funktionierts mit der Property nicht und er wundert sich warums nicht geht.

Verstanden was ich will?

[Namenloser]

Zitat von Neutral General:

Verstanden was ich will?

Ja, verstanden, glaub ich. Hmm, also ich fürchte, dass das nicht wirklich machbar ist. Allerdings kannst du dir unter Umständen das Delphi-Konstrukt index zu Nutze machen:

Delphi-Quellcode:

type
  TBaseClass = class
  private
    FFields: array of integer;
  protected
    function GetField(Index: integer);
    procedure SetField(Index: integer; Value: integer);
    procedure SetFieldCount(Count: integer);
  end;

  TDerivedClass = class(TBaseClass)
  public
    property Value1: integer index 0 read GetField write SetField;
    property Value2: integer index 1 read GetField write SetField;
    property Value3: integer index 2 read GetField write SetField;
    constructor Create;
  end;

implementation

function TBaseClass.GetField(Index: integer);
begin
  Result := FFields[Index];
end;

procedure TBaseClass.SetField(Index: integer; Value: integer);
begin
  FFields[Index] := Value;
end;

procedure TBaseClass.SetFieldCount(Count: integer);
begin
  SetLength(FFields, Count);
end;

constructor TDerivedClass.Create;
begin
  SetFieldCount(3);
end;

[sx2008]

Jetzt hab ich verstanden, was du eigentlich erreichen möchtest.
Du hast eine x-beliebige Klasse, die nicht verändert werden soll.
Dann möchtest du dich von Aussen an bestimmte Methoden und/oder Properties einhaken und
das Verhalten verändern.
http://upload.wikimedia.org/wikipedi...rammierung.png
Du könntest dann vor und nach dem Methodenaufruf zusätzliche Dinge ausführen, von denen die orginal Klasse nichts weiss.
In dem Bild steckt das in dem roten Kreis.
Mit dieser Technik des Abfangens von Methodenaufrufen könntest du Dinge tun, an die der Programmierer der Klasse nicht gedacht hat.
Man nennt das Aspektorientierte Programmierung.
Leider ist Delphi (wie auch die meisten anderen Prog.Sprachen) dazu noch nicht in der Lage.

[Neutral General]

Zitat von sx2008:

Man nennt das Aspektorientierte Programmierung.
Leider ist Delphi (wie auch die meisten anderen Prog.Sprachen) dazu noch nicht in der Lage.

Meinst du, es könnte irgendwie möglich sein, dass selbst nachzurüsten?