Abstract factory design pattern and generics - Java

Question

It's the first time I'm using this design pattern and I'm having some difficulties. Taking this image as reference:

I have two AbstractProduct that I would like to create a factory for, since they come in different "families". One of the products is a collection of the other.

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

Note that FrameMap is a collection of F (I omitted most of the other methods for simplicity), so it needs to be able to get and put elements. Taking one family as an example (the one for App1) these are the concrete Product:

public class App1Frame extends Frame{
    ...
}

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

Then I have created the AbstractFactory:

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

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

And the ConcreteFactory for App1:

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

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

All of this compiles, but I'm not liking it very much because my Client cannot do something like:

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

which is, at least conceptually, the goal of the pattern, i.e. letting the client only use the abstract classes. In order to make it work, I have to do something like this:

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

which seems going against the purpose of using the design pattern.

Do you know any better way of implementing this pattern in a situation like mine, i.e. using generics in the AbstractProduct, in order to let the Client only use the abstract classes without knowing the underlying implementation?

Answer 1

You can add the generic type to the 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();
    }
}

Also note the ApplicationFactory object should be injected into the client. If the client directly calls new App1Factory() there is no point to the abstraction. The client might as well use App1Factory after creating it.

Answer 2

Further to @jaco0646 solution, there is a simple way to resolve the problem of adding a freshly created frame to a map even if you don't know in runtime the actual subtype or "family". That is as long as you can tie both the frame and frame-map type parameter to have the same value within a method like so:

public static <T extend Frame> FrameMap<T> makeAndAdd(final AbstractFactory<T> factory) {
    T frame = factory.makeFrame();
    FrameMap<T> map = factory.makeFrameMap();
    map.add(frame);
    return map;
}

When it is not possible to put both actions in the same method (e.g. the occur assyncronously on different server calls). You can still achieve this tie by using a yet another class with a type-parameter and that have different methods of those actions... this is a bit more complex that would need to be tailored to the actual problem but the idea is the same in the sense that you use a type-parameter to tie the type-parameter values given to different object in run-time.