Objekthierarchie

Question

Was ist das korrekte Modell für ein Einzelhandelsgeschäft? z.B. Das Unternehmen verkauft Produkte aus Stores.

Ein Unternehmen kann viele Geschäfte haben und viele Produkte verkaufen. Die Produkte sind nicht unbedingt an jeden Laden gebunden, oder so hätte ich gedacht.

Ich habe eine grundlegende Zuordnung, die fordert, dass ich ein System entwerfe, das die wirtschaftliche Bestellmenge eines Produkts berechnet. Wir sollen eine Struktur implementieren, die für eine spätere Zuordnung (für die wir keine Details ..) geeignet sein wird, und die empfohlene Struktur ist wie folgt:

public class Company { 
    private Store store; 

    public static void main(String[] args) 
    { 
     Store storeOne = new Store(); 

     storeOne.setEOQRelevantValues(1, etc..); 
    } 
} 

public class Store { 
    private Product product; 

    //.. 

    public setEOQRelevantValues(int eoqRelevantValues) 
    { 
     Product.setEOQRelevantValues(eoqRelevantValues); 
    } 
} 

public class Product{ 
    private int eoqRelevantValues; 

    //.. 

    public setEOQRelevantValues(int eoqRelevantValues) 
    { 
     this.eoqRelevantValues = eoqRelevantValues; 
    } 

    public int calculateEOQ() 
    { 
     //do stuff with this.eoqRelevantValues.. 
     return EOQ; 
    } 
} 

Dies scheint all die kleinen ich zu verletzen wissen über OOP. Methoden, die Daten durch die Hierarchie leiten - Duplizieren von Parametern zwischen Objekten? Was vermisse ich?

Answer 1

Sie haben Bedenken, dass es ungewöhnlich wäre, eine Hierarchie von Objekten zu initialisieren, indem Sie alle Parameter von oben nach unten übergeben.

Ihr Dozent deutet möglicherweise an, dass Sie etwas nach dem Muster "Composite" implementieren, wobei jede Klasse in der Hierarchie eine gemeinsame Methode verwendet (z. B. getValue()). Im Falle eines Product (d. H. Blatt-Knotens) würde dies einfach den Produktwert zurückgeben, während es im Falle eines Store oder Company über den Bestandteil Product s (oder Store s) iteriert und getValue() aufruft und das Ergebnis summiert.

Der Hauptunterschied zwischen diesem und dem, was Sie oben geschrieben haben, ist, dass Sie normalerweise jede Product einzeln über ihren Konstruktor initialisieren, anstatt die Daten von einem anderen Objekt zu übergeben. Wenn das Produkt unveränderlich ist, können Sie die Felder als final markieren. Sie könnten dann auswählen, Hilfsmethoden anderen Klassen in der Hierarchie hinzuzufügen (z. B. moveProduct(Store store1, Store store1)); Mit anderen Worten, die anderen Klassen würden dann Verhalten zeigen, anstatt nur "Datencontainer" zu sein.

Beispiel

/** 
* Optional interface for uniting anything that can be valued. 
*/ 
public interface Valuable { 
    double getValue(); 
} 

/** 
* Company definition. A company's value is assessed by summing 
* the value of each of its constituent Stores. 
*/ 
public class Company implements Valuable { 
    private final Set<Store> stores = new HashSet<Store>(); 

    public void addStore(Store store) { 
    this.stores.add(store); 
    } 

    public void removeStore(Store store) { 
    this.stores.remove(store); 
    } 

    public double getValue() { 
    double ret = 0.0; 

    for (Store store : stores) { 
     ret += store.getValue(); 
    } 

    return ret; 
    } 
} 

/** 
* Store definition. A store's value is the sum of the Products contained within it. 
*/ 
public class Store implements Valuable { 
    private final List<Product> products = new LinkedList<Product>(); 

    public void addProduct(Product product) { 
    this.products.add(product); 
    } 

    public void removeProduct(Product product) { 
    this.products.remove(product); 
    } 

    public double getValue() { 
    double ret = 0.0; 

    for (Product product : products) { 
     ret += product.getValue(); 
    } 

    return ret; 
    } 
} 

/** 
* Product definition. A product has a fixed inherent value. However, you could 
* always model a product to depreciate in value over time based on a shelf-life, etc. 
* In this case you might wish to change the Valuable interface to accept a parameter; 
* e.g. depreciationStrategy. 
*/ 
public class Product implements Valuable { 
    private final double value; 

    public Product(double value) { 
    this.value = value; 
    } 

    public double getValue() { 
    return value; 
    } 
}