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

我有以下问题：

有一个通用的工厂接口

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

这些类型的工厂有两个：

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

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

接口工厂扩展工厂{
公共T1创建（）；
}
接口工厂扩展工厂{
公共T2创建（）；
}

对于这些工厂，将通过泛型提供默认实现：

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

类DefaultFactory实现工厂{
私营F工厂；
...
公共文件不能创建（）
{
返回factory.create（）；
}
}

这应该用于实现T1和T2的工厂

class DefaultT1Factory extends DefaultFactory<T1,T1Factory> {
}

class DefaultT2Factory extends DefaultFactory<T2,T2Factory> {
}

class DefaultT1Factory扩展了DefaultFactory{
}
类DefaultT2Factory扩展了DefaultFactory{
}

到目前为止，一切正常。现在问题来了。 因为T2是T1的细化，T2的工厂也应该可用作T1的工厂

这要求T2Factory从T1Factory派生。如果我这样做，我就不能使用DefaultFactory类来实现DefaultT2Factory，因为T2Factory不是工厂。 如果我将此关系添加到T2Factory的extends子句中，我会得到一个错误，即接口工厂被多次使用。但是我需要工厂接口，以便能够在默认实现中使用create方法

从方法签名的角度来看，一切都很好。因此，我必须将默认实现的实现复制到to-factory实现中。在我的例子中，这种编码相当大，我希望避免代码重复

你知道如何避开这个问题吗。

我想你是说

因为T2是T1的细化，T1的工厂也应该可用作T2的工厂。 T1工厂不应用作T2工厂，因为T1不是T2。但是T2是T1，因此T2工厂可以安全地用作T1工厂（或视为T1工厂）

公共接口工厂扩展工厂{
公共T1创建（）；
}

现在，当您实现这个接口时，可以这样说

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

公共类Foo实现了T1Factory{
公共T1创建（）{
.....
}
}

现在，接口基本上可以用扩展的或是T1的任何类型参数化。在本例中，您表示希望利用T2是T1关系

希望对您有所帮助

您可以使用它来定义T的工厂或T的任何子类型。如果您将

DefaultFactory的签名更改为

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

classdefaultfactory我想我已经找到了一个解决方案，虽然不是很好，但似乎很有效。之前的答案几乎是可行的，但是使用super而不是extends。
重要的一点是能够重用实现

当使用super来放松factory元素的类型约束时，这应该是可能的

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

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

class defaultFactory为什么
T2
的工厂也可用作
T1
的工厂？因为T2也可以像T1s一样使用。因此，我需要T1的工厂，我也希望能够传递T2的工厂。基本上，我可以这样写：接口T2Factory扩展T1Factory{T2 create（）；}覆盖create方法可以细化返回类型，并且一切正常。不幸的是，我不能为T1Factory和T2Factory接口使用上面显示的默认实现。如果我可以从FactoryT2进行额外的扩展，它会工作，但在Java中这是不可能的。方法签名将完全匹配，因为只优化了返回类型。
class DefaultFactory<T, F extends Factory<? extends T>> implements Factory<T> {

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

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