Datenstruktur elegant zerlegen

[Biesterfeld]

Hej,

man stelle sich vor, man habe eine relativ große Datenstruktur (eigentlich ein Container der mehrere Sets verschiedener Elementtypen enthält).
Dieser Container soll hierarchisch modularisiert werden. Also die Inhalte des Containers werden nach einem Bestimmten Kriterium in verschiedene Subcontainer gepackt, die dann wiederrum weiter zerlegt werden können, usw...

Wichtig noch: Die Modularisierung soll zwar jeweils immer nur nach einem Kriterium erfolgen, es sollen aber verschiedene Kriterien angeboten werden, nach denen zerlegt werden kann.

Nun die Frage welcher Ansatz der eleganteste ist:

a) der Container bringt selber die Methoden seiner Zerlegung mit.
b) es gibt einen abstrakten Zerleger, der je nach Kriterium eine konkreten Zerleger beerbt, dieser wird mit dem Container gefüttert und gibt als Ergebnis das Zerlegungsobjekt zurück.
c) das Ergebnisobjekt wird beim instanzieren mit dem Container und der Zerlegungsklasse gefüttert.

Beste Grüße
Biesterfeld

 

[Campino]

b) es gibt einen abstrakten Zerleger, der je nach Kriterium eine konkreten Zerleger beerbt, dieser wird mit dem Container gefüttert und gibt als Ergebnis das Zerlegungsobjekt zurück.

Ich würde den nehmen, Frag mich nicht warum...Also eine hochqualifizierte Antwort *wink*

 

[Illuvatar]

Campino nimmt im Zweifelsfall das was er nicht versteht :bae:

Ne, im Ernst, ich wär auch für b), da das am Besten veränderbar/erweiterbar ist wenn man den konkreten Zerleger ändert.

 

[Campino]

Campino nimmt im Zweifelsfall das was er nicht versteht :bae:

Ne, im Ernst, ich wär auch für b), da das am Besten veränderbar/erweiterbar ist wenn man den konkreten Zerleger ändert.

Wenn du kein Mod wärst...

 

[Snape]

Hej,

man stelle sich vor, man habe eine relativ große Datenstruktur (eigentlich ein Container der mehrere Sets verschiedener Elementtypen enthält).
Dieser Container soll hierarchisch modularisiert werden. Also die Inhalte des Containers werden nach einem Bestimmten Kriterium in verschiedene Subcontainer gepackt, die dann wiederrum weiter zerlegt werden können, usw...

Wichtig noch: Die Modularisierung soll zwar jeweils immer nur nach einem Kriterium erfolgen, es sollen aber verschiedene Kriterien angeboten werden, nach denen zerlegt werden kann.

Nun die Frage welcher Ansatz der eleganteste ist:

a) der Container bringt selber die Methoden seiner Zerlegung mit.
b) es gibt einen abstrakten Zerleger, der je nach Kriterium eine konkreten Zerleger beerbt, dieser wird mit dem Container gefüttert und gibt als Ergebnis das Zerlegungsobjekt zurück.
c) das Ergebnisobjekt wird beim instanzieren mit dem Container und der Zerlegungsklasse gefüttert.

Beste Grüße
Biesterfeld

Prinzipiell klingen a) und b) fast gleichwertig. Allerdings habe ich nicht so recht verstanden, was Du mit dem Beerben eines konkreten Zerlegers meinst, mit Container füttern usw. Sollen die Subcontainer abgeleitete Klassen von Container werden? Wenn ja, dann würde ich b) bevorzugen, ist alles schön sauber getrennt und jeder Container kann sich die Subsets holen/erstellen, die er braucht.

 

[Bleiglanz]

würde sagen "Strategy-Pattern" ausnahmsweise mal angebracht

Container hat eine Membervarialbe Zerleger

Zerleger ist ein Interface

über einen setter kannst du einem Container dann einen konkreten Zerleger unterjubeln

Container hat methode zerlegMich(), die einfach an den Member-Zerleger delegiert

 

[Biesterfeld]

Hej,

a) der Container bringt selber die Methoden seiner Zerlegung mit.
b) es gibt einen abstrakten Zerleger, der je nach Kriterium eine konkreten Zerleger beerbt, dieser wird mit dem Container gefüttert und gibt als Ergebnis das Zerlegungsobjekt zurück.

Prinzipiell klingen a) und b) fast gleichwertig. Allerdings habe ich nicht so recht verstanden, was Du mit dem Beerben eines konkreten Zerlegers meinst, mit Container füttern usw. Sollen die Subcontainer abgeleitete Klassen von Container werden?

Also a) und b) sind in meinen Augen vollkommen verschieden:

a) :

class Container implements SuperContainer{
  ...
  public ZerlegterContainer zerlegMich(int kriterium){
    case(kriterium){
      switch 1:
       ...
    }
    return output;
  }
}

b) :

abstract class Zerleger{
  
  protected SuperContainer     input;
  protected ZerlegterContainer output;
  
  public Zerleger(Supercontainer input) {
    this.input = input;
  }

  public ZerlegterContainer gibZurueck(){
    return output;
  }

  private void zerlege();
}

public class ZerlegeNachKriterium1 extends Zerleger{
  
  public ZerlegeNachKriterium1(SuperContainer input){
    super(input);
  }

  private void zerlege{
    ...
  }
}

Und die dritte Idee:

public final class Zerleger{
  int kriterium;
  public static final Zerleger ZERLEGE_NACH_KRITERIUM = new ZERLEGER(1);
  ...

  private Zerleger(int kriterium){
    this.criterion = kriterium;
  }

  public zerlege(SuperContainer){
    switch (this.kriterium){
      case 1:
      ....
    }
  }
}

public class ZerlegterContainer implements SuperContainersErbe{
  ...
  public ZerlegterContainer(Supercontainer input, Zerleger zerleger){
    zerleger.zerlege(input);
  }
  ...
}

Ich denke das es jetzt klar geworden ist?

Die Idee ist vor allem, dass ich den orginal Container nicht ändern möchte, weil ich ihn eben mehrmals auf verschiedene art und weise zerlegen muss. Daher ist jede Zerlegung eine neue Instanz.
Zerlegung und Container gehören auch dem gleichen Superinterface an, implementieren aber dessen verschiedene Erben.

Naja, is jetzt schon etwas sehr ausführlich geworden. Der Grundtenor war ja dass die Methode b) wohl die gebräuchlichste sei. Allerdings fühlte ich mich etwas (da ich die letzten Tage viel damit gearbeitet hatte) durch die Interfaces Comparator und Comparable inspiriert, die ja eher die Methoden a) bzw. c) repräsentieren.

So far, vielen Dank und beste Grüße
Biesterfeld