对象层次结构

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（或store)，调用getValue()并求和结果。

这与上面所写内容的主要区别在于，您通常会通过每个product的构造函数单独初始化每个product而不是通过从另一个对象传入数据来初始化每个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;
  }
}