实例化泛型类并实现泛型接口

Question

我有这个类：

public DrawItem {
    protected String getSeperator() {
        return "";
    }
    .......
    // some other methods
}

我还有另一个扩展DrawItem的类。

public DrawNumber extends DrawItem {
    @Override
    protected String getSeperator() {
        return "-";
    }
}

现在，在一个泛型类CombinationGenerator<E>中，我正在尝试实例化DrawItem/DrawNumber的对象。由于在 java 中无法实例化泛型类型（如 new E(...)），我根据这个答案创建了一个工厂接口。

public interface DrawItemFactory<E> {
    E create(...);
}

然后在CombinationGenerator<E>课上，

public class CombinationGenerator<E> {
    DrawItemFactory<E> factory;
    public CombinationGenerator<E>(DrawItemFactory<E> factory) {
        this.factory = factory;
    }
    public List<E> generate() {
        ......
        list.add(factory.create(...));
        ......
    }
}

现在，DrawNumber类实现了DrawItemFactory<DrawItem>接口。

public DrawItem implements DrawItemFactory<DrawItem> {
    protected String getSeperator() {
        return "";
    }
    @Override
    public DrawItem create(...) {
        return new DrawItem(...);
    }
    .......
    // some other methods
}

我可以创建CombinationGenerator<DrawItem>类。

DrawItem drawItem = new DrawItem(...);
CombinationGenerator<DrawItem> generator = new CombinationGenerator<DrawItem>(drawItem);
List<DrawItem> combinations = generator.generate();

到目前为止，一切都很好。但是当我尝试创建一个这样的DrawNumber类时，

public DrawNumber implements DrawItemFactory<DrawNumber> {
     ....
}

它给了我以下错误：

The interface DrawItemFactory cannot be implemented more than once with different arguments: DrawItemFactory<DrawItem> and DrawItemFactory<DrawNumber>

我已经尝试了这个解决方案，但我得到了同样的错误。还有其他方法可以做到这一点吗？

Answer 1

与其使用所有这些工厂，你可以做这样的事情：

public class CombinationGenerator<E> {
    E instance;
    public CombinationGenerator(Class<E> clazz) {
        Constructor<?> con = clazz.getConstructor();
        this.instance = (E) con.newInstance();
    }
}

。
CombinationGenerator<DrawNumber> cg = new CombinationGenerator<DrawNumber>(DrawNumber.class);

Answer 2

根据@JB Nizet的评论，我通过创建两个单独的工厂类解决了这个问题，如下所示：

public interface ItemFactory<E> {
    E create(int[] values);
    public static class DrawItemFactory implements ItemFactory<DrawItem> {
        @Override
        public DrawItem create(int[] values) {
            return new DrawItem(values);
        }           
    }
    public static class DrawNumberFactory implements ItemFactory<DrawNumber> {
        @Override
        public DrawNumber create(int[] values) {
            return new DrawNumber(values);
        }           
    }
}

在CombinationGenerator，

public class CombinationGenerator<E> {
    ItemFactory<E> factory;
    public CombinationGenerator<E>(ItemFactory<E> factory) {
        this.factory = factory;
    }
    public List<E> generate() {
        ......
        list.add(factory.create(...));
        ......
    }
}

并像这样实例化CombinationGenerator：

DrawNumber drawNumber = new DrawNumber();
CombinationGenerator<DrawNumber> generator = new CombinationGenerator<DrawNumber>(new ItemFactory.DrawNumberFactory());
List<DrawNumber> combinations = generator.generate();