Setter mehrfach überschreiben.

[Bjoerk]

In den Zusammenhang stellt sich für mich die Frage, ob es möglich ist, eine Faktory aus 3 unterschiedlichen Klassen zu erstellen. Falls da ja jemand irgendeine Chance sieht, mach in nen neuen Thread auf.

[DeddyH]

Meiner Meinung nach sieht das schon aufgrund der Vielzahl an Properties und Methoden arg nach Gottklasse aus. Evtl. wäre es besser, das Design noch einmal zu überdenken. Abstrakte Methoden verwendet man z.B., wenn jede abgeleitete Klasse sie implementieren muss, es aber auf dieser Hierarchiestufe noch keine Gemeinsamkeit gibt außer der Methode an sich. So kann sich z.B. jedes Fahrzeug bewegen (da dies ja sein essentieller Sinn ist), aber jedes anders (Flugzeuge fliegen, Landfahrzeuge fahren, Wasserfahrzeuge schwimmen). Auf der Stufe TFahrzeug macht es also durchaus Sinn, eine abstrakte Methode "Bewege" einzuführen. Erst wenn es so "speziell" wird, dass es einen gemeinsamen Nenner gibt, erfolgt dann die (erste) Implementation, die auf weiteren Stufen ggf. noch überschrieben werden kann. Zu Deiner Factory: wäre es nicht sinnig, hier Interfaces einzuführen? Je weiter man sich durch den Klassenbaum nach unten bewegt, desto mehr Interfaces werden dann eben implementiert. Ob eine Klasse ein bestimmtes Interface implementiert, lässt sich ja erfragen.

Just my 2 cents.

[Bjoerk]

Ja, ist sehr aufgebläht. Diese Klasse hab ich eigentlich nur deshalb eingeführt um keine Fehler zu machen (auf protected-Symbol TWerkzeug.xyz kann nicht zugegriffen werden) und um einen gemeinsamen Vorfahren zu haben.

Ableiten wär mir eigentlich lieber als interfaces?

[DeddyH]

Ableiten ginge auch, dann prüft man eben nicht, ob ein bestimmtes Interface imlpementiert, sondern ob das Objekt von einem bestimmten Klassentyp ist.

[Bjoerk]

Ich hab diese fürchterliche Basisklasse geschreddert (nicht nur gelöscht). Die bringt überhaupt nichts null nothing gar nichts. Ich habe 3 Kategorien von geometrischen Objekten, die ich eh immer abfragen muß?

Beispiel:

Delphi-Quellcode:

procedure TDrawPadProperties.SetProperties(Item: TWerkzeug0);
var
  Item1: TWerkzeug1;
  Item2: TWerkzeug2;
  Item3: TWerkzeug3;
begin
  SetProperties0(Item);
  if Item is TWerkzeug1 then
  begin
    Item1 := TWerkzeug1(Item);
    SetProperties1(Item1);
  end
  else
    if Item is TWerkzeug2 then
    begin
      Item2 := TWerkzeug2(Item);
      SetProperties2(Item2);
    end
    else
    begin
      Item3 := TWerkzeug3(Item);
      SetProperties3(Item3);
    end;
end;

[Mikkey]

Nö, so wird ein Schuh draus:

Delphi-Quellcode:

Procedure TWerkzeug0.SetProperties();
begin
    ...
end;

Procedure TWerkzeug1.SetProperties();
begin
    inherited SetProperties();
    ...
end;
...

Sonst baust Du ja die Logik nach, die Dir durch OOP zur Verfügung gestellt wird.

[Dejan Vu]

Wieso schreibst Du dir keinen WerkzeugPropertySetter und eine Factory, die Dir zu dem Werkzeug ('Item') die passende Klasse liefert, welche dann die Daten setzt. Wenn bei deinem Ansatz nämlich noch ein TWerkzeug4 hinzukommt, musst Du deinen Code anpassen, und das wäre dann so gar nicht OCP.

Delphi-Quellcode:

Type
  IWerkzeugPropertySetter = interface
    SetProperties(Item : TWerkzeug0);
  end;

procedure TDrawPadProperties.SetProperties(Item: TWerkzeug0);
var
  propertySetter : IWerkzeugPropertySetter;

begin
  propertySetter := WerkzeugPropertySetterFactory.Create(Item);
  propertySetter.SetProperties(Item);
end;

Leider musst Du in den einzelnen Setterklassen dann dein 'Item' immernoch konkret auf TWerkzeugX casten, aber da Du keine Generics benutzt, bleibt dir hier dann wohl nichts anderes übrig. Mit Generics würde das so aussehen (so ungefähr jedenfalls)

Delphi-Quellcode:

Type
  IWerkzeugPropertySetter<T : TWerkzeug0> = interface
    SetProperties(Item : T);
  end;

  WerkzeugPropertySetterFactory = class
    Function Create<T : TWerkzeug0> (Item : T) : IWerkzeugPropertySetter<T>;
  End;

procedure TDrawPadProperties.SetProperties<T:TWerkzeug0>(Item: T);
var
  propertySetter : IWerkzeugPropertySetter<T>;

begin
  propertySetter := WerkzeugPropertySetterFactory.Create<T>(Item);
  propertySetter.SetProperties(Item);
end;

Und das wäre dann typsicher. Wenn nun ein 4. Werkzeug hinzukommst, schreibst Du eine neue Klasse dafür und registrierest diese in der Factory.