对精炼工厂使用通用通用默认实现

Question

I have the following problem:

There is a generic Factory interface

interface Factory<T> {
  T create();
}

Now I have two classes T1 and T2, where T2 is a refinement of T1

class T1 {
}

class T2 extends T1 {
}

and two factories for those types:

interface T1Factory extends Factory<T1> {
  public T1 create();
}

interface T2Factory extends Factory<T2> {
  public T2 create();
}

For those factories a default implementation will be provided via Generics:

class DefaultFactory<T, F extends Factory<T>> implements Factory<T> {
  private F factory;
  ...
  public T create()
  {
    return factory.create();
  }
}

that should be used to implement factories for T1 and T2.

class DefaultT1Factory extends DefaultFactory<T1,T1Factory> {
}

class DefaultT2Factory extends DefaultFactory<T2,T2Factory> {
}

Up to here it works fine. Now the problem. Because T2 is a refinement of T1 the Factory for T2 should be usable also as factory for T1.

This requires T2Factory to be derived from T1Factory. If I do this I cannot use the DefaultFactory class to implement the DefaultT2Factory, because T2Factory is no Factory<T2>. If I add this relationship to the extends clause of T2Factory I got the error that the interface Factory is used more than once. But I need the Factory interface to be able to use the create method in the default implementation.

From the point of method signatures everything is fine. As a consequence I've to duplicate the implementation of the default implementation into the to factory implementation. In my case this coding is quite large and I want to avoid code duplication.

Any idea how to circumvent this problem.

Answer 1

I think you meant

Because T2 is a refinement of T1 the Factory for T1 should be usable also as factory for T2. A factory of T1 should not be used as a factory of T2 because T1 IS NOT T2. However T2 IS T1, so a factory for T2 can be safetly used as a factory of T1(or treated as a factory of T1)

   public interface T1Factory<J extends T1> extends Factory<T1> {
             public T1 create();
        }

Now when you implement this interface, its cool to say something like

public class Foo implements T1Factory<T2> {
         public T1 create(){
                    .....
          }
 }

Now basically the interface can be parameterized with any type that extends or is T1. In this case you stated you wanted to take advantage of the T2 is a T1 relationship.

Hope that helps

Answer 2

You can use wildcard to define something like Factory of T or any subtype of T . If you change signature of DefaultFactory to

class DefaultFactory<T, F extends Factory<? extends T>> implements Factory<T> {

Then you should be able to have DefaultFactory<T1, T2Factory> .

Answer 3

I think I've found a solution, not really nice, but it seems to work. The answer before is nearly working, but use super instead of extends . The important point is just to be able to reuse the implementation.

This should be possible when relaxing the type constraint for the factory element by using super.

class DefaultFactory<T, F extends Factory<? super T>> {
  private F factory;

  @SuppressWarnings("unchecked")
  public T create()
  {
    return (T)factory.create();
  }
}

The price is the type unsafetyness when calling the create method, which required an unsafe type cast. But the rest seems to work as expected.

T2Factory thereby has to extend T1Factory . Then it is unfortunately not a Factory<T2> , but this was required only for being able to call the create method in the default implementation returning the correct type. And for this purpose it is sufficient to be a Factory<T1> (which causes the required type cast).