Verwendung von Instanzen einer Klasse als Referenz

Question

Ich brauche etwas Hilfe auf meinem Klassen-Design oder besser gesagt, einen Verweis auf ein gemeinsames Design-Muster für ein Problem.

Ich arbeite in der Flugzeugindustrie. Bisher sind meine Programmierkenntnisse VBA und grundlegende JAVA-Anwendungen. Als Ingenieur ist es meine Aufgabe, CAD-Modelle für die Fixierung von Komponenten in und an Flugzeugküchen zu erstellen. Um eine hohe Wiederverwendbarkeit zu gewährleisten und die Entwicklungszeit zu reduzieren, möchte ich ein Programm erstellen, das bisherige Lösungen empfehlen kann. Grundsätzlich kann jeder Flugzeugbetreiber aus einem Katalog auswählen, welche Galeeren/Küchen (Monument) er installiert haben möchte. Innerhalb dieser Denkmäler sind mehrere Fächer. In einem Fach können wir mehrere Geräte/Komponenten installieren. Ich möchte ein Programm schreiben, das mir sagen kann "Sie haben diese Komponenten zusammen installiert -> In diesem Fach -> in diesem Flugzeug für diesen Kunden"

Ich habe das Fach, die Denkmäler und das Flugzeug modelliert . Jede Klasse erweitert die gleiche Klasse BaseHolder bilden:

public abstract class BaseHolder <I> { 

    private final ArrayList <I> heldItems = new ArrayList<I>(); 

    public boolean addItem(final I i){ 
     Objects.requireNonNull(i, "cannot add NULL"); 
     return heldItems.add(i); 
    } 

    public boolean removeItem(I i){ 
     return heldItems.remove(i); 
    } 

    public boolean contains(I i){ 
     return heldItems.contains(i); 
    } 

    public int itemCount(){ 
     return heldItems.size(); 
    } 

    public boolean isEmpty(){ 
     return heldItems.isEmpty(); 
    } 

    public void Clear() { 
     heldItems.clear(); 
    } 

    protected List<I> getHeldItems(){ 
     return heldItems; 
    } 

    public I getElement(int n){ 
     return heldItems.get(n); 
    } 
} 

public class Aircraft extends BaseHolder<Monument> { 
    // code 
} 

public class Monument extends BaseHolder<Compartment> { 

    private String name; 

    public Monument (String name){ 
     this.setName(name); 
    } 

    // code 

    @Override 
    public boolean addItem(final Compartment c) { 
     Objects.requireNonNull(c, "cannot add NULL"); 

     if (contains (c)){ 
      throw new IllegalArgumentException("Compartment already added!"); 
     }; 

     for(Compartment ctmp : getHeldItems()){ 
      if (ctmp.getName().equals(c.getName())) { 
       throw new IllegalArgumentException("Compartment with an identical name already exits"); 
      } 
     } 
     return getHeldItems().add(c); 
    } 

    public Compartment getCompartment(int n){ 
     return getHeldItems().get(n); 
    } 

    public Compartment getCompartment(String name){ 
     for(Compartment ctmp : getHeldItems()){ 
      if (ctmp.getName().equals(name)) { 
       return ctmp; 
      } 
     } 
     return null; 
    } 
} 

public class Compartment extends BaseHolder<IWeighable>{ 

    private String name = ""; 
    private double MAX_LOAD = 0.0; 

    public Compartment (String name ,final double max_load){ 
     this.setName(name); 
     updateMaxLoad(max_load); 
    } 

    // code 

    protected double getTotalLoad(){ 
     // code 
    } 

    /** 
    * 
    * @param load 
    * @throws InvalidParameterException if max load not >= than 0.0 
    */ 
    public void setMaxLoad(final double load){ 
     if (load >= 0.0){ 
      this.MAX_LOAD = load; 
     } else { 
      throw new InvalidParameterException("max load must be greater than 0.0"); 
     } 
    } 

    public boolean isOverloaded(){ 
     return (getTotalLoad() > MAX_LOAD) ; 
    } 
} 

Das Problem, das ich habe, ist, dass dieser Entwurf viele Mängel zu haben scheint. Abgesehen davon, dass es ziemlich mühsam ist: getElement (n) .getElement (n) .getElement (n) Das Hinzufügen von Elementen zu einem Compartment führt dazu, dass alle Flugzeuge das gleiche Compartment verwenden und die gleichen Komponenten/Komponenten installiert sind. Da es sich um das gleiche Objekt in der DB handelt. Eine Instanz des Abteils wäre notwendig. Das Klonen des DB Compartments vor dem Hinzufügen zu einem Flugzeug ist keine Option. Ich muss in der Lage sein, die zulässigen Lasten zu ändern, eine Änderung für alle. Um dieses Problem zu beheben Ich dachte an eine Art von „Wrapper“ Klasse, wie Sie sich mit:

public class MonumentManager { 

    public ArrayList <Monument> monuments = new ArrayList<>(); 
    public ArrayList <LinkObect> links; 

    class LinkObect{ 
     private Compartment c; 

     private IWeighable e; 

     LinkObect(Compartment c, IWeighable e){ 
      this.c = c; 
      this.e = e; 
     } 
    } 

    public boolean addMonument(Monument m){ 
     return monuments.add(m); 
    } 

    public void addElementToCompartment(IWeighable e, Compartment c){ 
     boolean known = false; //to check if the passed compartment is known/handeld to/by the MonumentManager 
     for (Monument m : monuments){ 
      if (m.getCompartment(c.getName()) != null) known = true; 
     } 

     if (known){ 
      links.add(new LinkObect(c, e)); 
     } else { 
      throw new IllegalArgumentException("Compartment is not inside a managed Monument!"); 
     } 
    } 

    public List<Compartment> whereUsed(IWeighable e){ 
     // TODO 
    } 
} 

Diese Klasse könnte das Problem lösen, aber es ist fühlt sich seltsam. Kann mir jemand in die richtige Richtung auf ein gemeinsames Designmuster etc. hinweisen. Ich lese ein Buch aus der lokalen Bibliothek über Designmuster. Aber es scheint etwas über mir zu sein. (wie ist vielleicht meine Aufgabe).

Alle Vorschläge/Hilfe usw. würde sehr geschätzt werden.

Answer 1

Ich hoffe, ich verstehe das richtig.

Eine Sache ist die Component, die Sie installieren möchten, die bestimmte Eigenschaften hat, und eine andere Sache ist eine Darstellung dessen, was Sie installiert haben.

Die Informationen Ihrer Installation müssen nicht in Ihrem Component sein, aber in etwas anderem, nennen wir es Installation.

Ihre Installation hat 2 Dinge wissen:

• Welche Art von Component es ist.
• Was andere Installations hat es innen.

Die Installation wird in etwa so aussehen.

public class Installation { 
    private Component type; 
    private List<Installation> content; 

    public Installation(Component type){ 
    this.type = type; 
    this.content = new ArrayList<Component>(); 
    } 

    //you can have methods for add, remove, etc... 
} 

Fühlen Sie sich frei, weitere Erläuterungen zu stellen.