Java 如何处理这个设计问题

场景

一个仓库，供应商和消费者。一个供应商只能生产一种材料。一个消费者也只能消费一种类型的东西。仓库知道供应商和消费者，但他们都不知道对方

---

我如何为这个场景中的所有参与者设计接口，并使用泛型来模拟它，以演示仓库如何与多个供应商、消费者和不同类型的东西一起工作

你想过二维矩阵吗

• 制作人
• 消费者

矩阵的内容定义了他们生产/消费的“东西”，以及是否允许他们有关系

---

这行吗？

我想您希望有一个

供应商

类和一个

消费者

类来实现泛型，这样您就可以在

仓库

类中实现

供应商

或

消费者

或其他东西了

你可以试试类似的方法。我想这更有可能实现一个泛型工厂

public class Supplier<T>{
    //You might decide you need an actual constructor that does something
    public Supplier(){}

    public T supplyItem(){
        return new T();
    }
}

公共类供应商{
//您可能会决定需要一个实际的构造函数来执行某些操作
公共供应商（）{}
公共T供应项目（）{
返回新的T（）；
}
}

消费者可能看起来像

public class Consumer<T>{

    private int consumeCount = 0;

    //You might decide you need an actual constructor that does something
    public Consumer(){}

    public void consumeItem(T item){
        consumeCount++;
    }

    public int consumeCount(){
        return consumeCount;
    }
}

公共类消费者{
私有int consumercount=0；
//您可能会决定需要一个实际的构造函数来执行某些操作
公共消费者（）{}
公共项目（T项目）{
消费者计数++；
}
public int consumercount（）{
返回消费计数；
}
}

最后，你的仓库可以包括这样的东西

Supplier<Integer> integerSupplier = new Supplier<Integer>();
Consumer<Integer> integerConsumer = new Consumer<Integer>();
Integer i = integerSuppler.supplyItem();
integerConsumer.consumeItem(i);
integerConsumer.consumeItem(integerSupplier.supplyItem());
System.out.println(integerConsumer.consumeCount());

Supplier integerSupplier=新供应商（）；
消费者积分消费者=新消费者（）；
整数i=integerSuppler.supplyItem（）；
整合消费者。消费者项目（i）；
integerConsumer.ConsumerItem（integerSupplier.supplyItem（））；
System.out.println（integerConsumer.consumercount（））；

我们希望打印“2”。你也可以改变你的消费方法，用

Object

代替

T

，然后用

instanceOf

来处理它，或者说“不能消费它，不是我的东西。”不过有一些事情你应该小心使用

instanceOf

，所以，如果它不需要那么健壮，我也不会担心它。对原因有很好的解释

编辑：看起来消费者和供应商正在相互交互，特别是当您有一行像

integerConsumer.consumeritem（integerSupplier.supplyItem（）），但需要注意的是，消费者和供应商实际上并没有在那里相互交流。供应商只是在生成一个新对象，而消费者则将此作为一个论据。虽然仓库知道消费者和供应商的存在，但消费者不知道供应商的存在，反之亦然。
仓库

public enum ITEMTYPE //known and public
Map<ITEMTYPE, count> items
Map<Supplier, ITEMTYPE> suppliers

registerSupplier(Supplier)
addItems(Supplier, count)

registerConsumer(Consumer)
consumeItems(Consumer, count)

消费者

ITEMTYPE type
ITEMTYPE getType()

使用方法：

Warehouse w = new Warehouse()
Supplier s1 = new Supplier(ITEMTYPE pens)
w.registerSupplier(s1)
w.addItems(s1, 10) // Update the data structure in warehouse with validations

Consumer c1 = new Consumer(ITEMTYPE pens)
w.registerConsumer(c1)
w.consumeItems(c1, 5) // Update the data structure in warehouse with validations

对我来说，如果没有一个具体的例子来说明这个程序应该做什么，就有点难说了。直观地说，我想说你甚至不需要接口或泛型，因为对象之间的差异可以通过属性来充分表征。我想使用泛型实现，程序应该解释仓库如何与多个供应商和消费者以及不同类型的物品一起工作，它的基础是仓库、客户和供应商在现实生活中如何工作的正常业务。描述它们之间相互作用的用例是什么？供应商向仓库供应商品，仓库向消费者供应商品，消费者和供应商没有直接的交互，他们总是通过仓库。仓库类看起来更像main（）方法。我包含了这段代码，以说明如何调用
消费者
和
仓库
。我想由Rachel来具体说明仓库需要什么：）
Warehouse w = new Warehouse()
Supplier s1 = new Supplier(ITEMTYPE pens)
w.registerSupplier(s1)
w.addItems(s1, 10) // Update the data structure in warehouse with validations

Consumer c1 = new Consumer(ITEMTYPE pens)
w.registerConsumer(c1)
w.consumeItems(c1, 5) // Update the data structure in warehouse with validations