java - 抽象工厂设计模式和泛型 - Java

Question

这是我第一次使用 this design pattern我遇到了一些困难。以此图为引用:

我有两个 AbstractProduct，我想为其创建一个工厂，因为它们属于不同的“家族”。其中一个产品是另一个产品的集合。

public abstract class Frame{
    ...
}

public abstract class FrameMap<F extends Frame>{
    protected TreeMap<Integer, F> map;

    public F readByKey(Integer key){
        return this.map.get(key);
    }

    public void put(Integer key, F frame){
        this.map.put(key,frame);
    }
    ...
}

请注意，FrameMap 是F 的集合(为简单起见，我省略了大部分其他方法)，因此它需要能够获取和放置元素。以一个家庭为例(App1 的那个)这些是具体的产品:

public class App1Frame extends Frame{
    ...
}

public class App1FrameMap extends FrameMap<App1Frame>{
    ...
}

然后我创建了AbstractFactory:

public abstract class ApplicationFactory{
    //Frame factory methods
    public abstract Frame makeFrame();

    //FrameMap factory methods
    public abstract FrameMap<? extends Frame> makeFrameMap();
}

还有 App1 的 ConcreteFactory:

public class App1Factory extends ApplicationFactory{
    //Frame factory methods
    public Frame makeFrame(){
        return new App1Frame();
    }

    //FrameMap factory methods
    public FrameMap<App1Frame> makeFrameMap(){
        return new App1FrameMap();
    }
}

所有这些都可以编译，但我不太喜欢它，因为我的客户不能做类似的事情:

ApplicationFactory factory = new App1Factory();
FrameMap<Frame> frameMap = factory.makeFrameMap(); //This doesn't compile!

至少在概念上，这是该模式的目标，即让客户端仅使用抽象类。为了让它工作，我必须做这样的事情:

App1Factory factory = new App1Factory();
FrameMap<App1Frame> frameMap = factory.makeFrameMap(); //This compiles!

这似乎违背了使用设计模式的目的。

您是否知道在像我这样的情况下实现此模式的更好方法，即在 AbstractProduct 中使用泛型，以便让客户端仅使用抽象类而不知道底层实现？

Answer 1

您可以将泛型类型添加到 ApplicationFactory。

public class MainJava {
    interface Frame{}
    interface FrameMap<T extends Frame>{}

    static class App1Frame implements Frame{}
    static class App2Frame implements Frame{}
    static class App1FrameMap implements FrameMap<App1Frame>{}
    static class App2FrameMap implements FrameMap<App2Frame>{}

    interface ApplicationFactory<T extends Frame> {
        T makeFrame();
        FrameMap<T> makeFrameMap();
    }

    static class App1Factory implements ApplicationFactory<App1Frame> {
        @Override public App1Frame makeFrame() {
            return new App1Frame();
        }
        @Override public FrameMap<App1Frame> makeFrameMap() {
            return new App1FrameMap();
        }
    }

    public static void main(String... args) {
        ApplicationFactory<? extends Frame> factory = new App1Factory();
        Frame frame = factory.makeFrame();
        FrameMap<? extends Frame> map = factory.makeFrameMap();
    }
}

还要注意 ApplicationFactory 对象应该是 injected进入客户端。如果客户端直接调用 new App1Factory()，则抽象没有意义。客户端也可以在创建后使用 App1Factory。