java - 用Java绑定(bind)多个类

我正在做一个分配，需要创建两个类的两个类的通用集合（称为ComputerOrder和PartyTrayOrder）：ComputerPart，Peripheral和Service，以及分别为Cheese，Fruit和Service。所有这些类（ComputerPart，Fruit，Service等）都扩展了一个称为Product的类。

我遇到的问题是，在Java中绑定多个类似乎是不可能的，因为您只能绑定多个接口，并且不允许修改现有的类结构。

我已经看过，并且看到它建议我创建和接口所有相关类的“代码”，但是我看不到没有ComputerPart，Peripheral等也可以作为接口然后使用extend关键字的情况。我已经看到它进一步建议我创建名为ComputerProduct和PartyTrayProduct的抽象类，但是我看不到这将如何以任何方式限制类型。

我不允许发布图片，但这是一个
class diagram, including some unrelated assignment objects

这是我当前的ComputerOrder代码，尽管它仅限制父类产品，这意味着它实际上不是赋值指定的。

public class ComputerOrder<T extends Product> extends GenericOrder<T> {
    public ComputerOrder() {
        super();
    }
}

以下是分配规范：


设计并实现一个名为GenericOrder的通用容器，该容器充当Products.java中任意数量的对象的集合。设计一种机制，为容器的每个实例赋予唯一标识符。您必须使用Java泛型功能。
设计并实现GenericOrder的子类，称为ComputerOrder，该子类采用任意数量的不同类的ComputerPart对象，外围对象和Service对象。实施尽可能多的方法。
设计并实现GenericOrder的子类PartyTrayOrder，该子类接受任意数量的不同类的Cheese对象，Fruit对象和Service对象。实施尽可能多的方法。
（...）

最佳答案

这是我想出的唯一解决方案，它遵循字母的分配并且仍然有意义（即使我认为这不是一个“好的”解决方案-请参阅下面的注释）：ComputerOrder和可以提供仅接受PartyTrayOrder特殊类型的方法：

abstract class Product {}
class ComputerPart extends Product {}
class Peripheral extends Product { }
class Cheese extends Product {}
class Fruit extends Product {}
class Service extends Product {}

abstract class GenericOrder<T extends Product> {
    protected final void addImpl(T t) {
    }
}

class ComputerOrder extends GenericOrder<Product> {
    void add(ComputerPart t) {
        addImpl(t);
    }
    void add(Peripheral t) {
        addImpl(t);
    }
    void add(Service t) {
        addImpl(t);
    }
}

class PartyTrayOrder  extends GenericOrder<Product> {
    void add(Cheese t) {
        addImpl(t);
    }
    void add(Fruit t) {
        addImpl(t);
    }
    void add(Service t) {
        addImpl(t);
    }
}

这样，订单实现可以完全接受正确的类型：

public class ProductExample {

    public static void main(String[] args) {
        ComputerOrder c = new ComputerOrder();
        c.add(new ComputerPart());
        c.add(new Peripheral());
        //c.add(new Cheese()); // Not allowed
        //c.add(new Fruit()); // Not allowed
        c.add(new Service());

        PartyTrayOrder p = new PartyTrayOrder();
        //p.add(new ComputerPart());  // Not allowed
        //p.add(new Peripheral());  // Not allowed
        p.add(new Cheese());
        p.add(new Fruit());
        p.add(new Service());

    }
}

我认为这是预期的解决方案，因为分配包含广泛的提示：


  实施尽可能多的方法。


因此，最有可能的目标不是实现一种神奇地限制多个类的方法。相反，必须为每个“类别”添加一种方法。



旁白：我的直觉是可以改进此设计。试想一下，您将必须为新的订单类型创建类Product和CarOrder等。或想象FahsionOrder必须扩展以处理PartyTrayOrder或Meat或Dip之类的类：您最终将获得带有许多专用方法的数十个类。

通过引入与特定“订单类型”可以接受的类型完全匹配的专用“产品类型”，可以避免所有这些情况。因此，我认为（Salad应该是一个开始的接口，并且）应该像Product和ComputerProduct这样的接口，例如

interface Product {}

interface ComputerProduct extends Product {}
class ComputerPart implements ComputerProduct  {}
class Peripheral implements ComputerProduct  {}

interface PartyTrayProduct extends Product {}
class Cheese implements PartyTrayProduct{}
class Fruit implements PartyTrayProduct{}

class Service implements Product {}
class DeliveryService implements PartyTrayProduct{}
class AssemblyService implements ComputerProduct  {}

这样，特定的PartyTrayProduct和ComputerOrder所需的边界已经使用类层次结构进行了建模。这样的好处是：您不再需要PartyTrayOrder和ComputerOrder类！然后，PartyTrayOrder可以是非抽象的，为了创建特定类型的订单，您只需正确地使用通用类型绑定即可。

这是一个完整的示例，其中我只是将GenericOrder作为新的Salad和PartyTrayProduct作为新的产品类型，而不必扩展或修改任何“基础结构类”：

interface Product {}

interface ComputerProduct extends Product {}
class ComputerPart implements ComputerProduct  {}
class Peripheral implements ComputerProduct  {}

interface PartyTrayProduct extends Product {}
class Cheese implements PartyTrayProduct{}
class Fruit implements PartyTrayProduct{}

class Service implements Product {}
class DeliveryService implements PartyTrayProduct{}
class AssemblyService implements ComputerProduct  {}

class Salad implements PartyTrayProduct{} // A new PartyTrayProduct

// Entirely new product type:
interface CarProduct extends Product {}
class CarPart implements CarProduct  {}
class CarInterior implements CarProduct  {}

class GenericOrder<T extends Product> {
    public void add(T t) { }
}

public class ProductExample2 {
    public static void main(String[] args) {

        GenericOrder<ComputerProduct> c = new GenericOrder<ComputerProduct>();
        c.add(new ComputerPart());
        c.add(new Peripheral());
        //c.add(new Cheese()); // Not allowed
        //c.add(new Fruit()); // Not allowed
        c.add(new AssemblyService());

        GenericOrder<PartyTrayProduct> p = new GenericOrder<PartyTrayProduct>();
        //p.add(new ComputerPart());  // Not allowed
        //p.add(new Peripheral());  // Not allowed
        p.add(new Cheese());
        p.add(new Fruit());
        p.add(new Salad()); // Just add it...
        p.add(new DeliveryService());

        // Easy to extend:
        GenericOrder<CarProduct> e = new GenericOrder<CarProduct>();
        e.add(new CarPart());
        e.add(new CarInterior());
    }
}