對象等級

Question

什麼是零售店的正確模式？例如公司從商店出售產品。

一家公司可以有很多商店和銷售許多產品。產品不一定與每家商店綁在一起，或者我可能會這麼想。

我有一個基本的任務，它要求我設計一個系統來計算產品的經濟訂貨量。我們應該實施，這將是適用於以後的分配（我們有沒有詳細說明。）的結構，並建議結構如下：

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; 
    } 
} 

這似乎違背了所有的小我的瞭解OOP。通過層次傳遞數據的方法 - 在對象之間複製參數？我錯過了什麼？

Answer 1

你是正確的擔心，通過從頂部向下傳遞所有參數來初始化對象層次結構是不正常的。

您的講師可能暗示您沿着複合模式的行執行某些操作，因此層次結構中的每個類共享一個常用方法（例如getValue()）。在Product（即葉節點）的情況下，這將簡單地返回產品的值，而在Store或Company的情況下，它將遍歷組分Product（或Stores），調用getValue()並對結果求和。

這和你之前寫的東西之間的主要區別是，你通常會通過它的構造函數單獨初始化每個Product，而不是通過傳入另一個對象的數據。如果產品不可變，您可以選擇將其字段標記爲final。然後，您可能會選擇將實用程序方法添加到層次結構中的其他類（例如moveProduct(Store store1, Store store1)）;換句話說，其他類將表現出行爲，而不僅僅是「數據容器」。

例

/** 
* 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; 
    } 
}