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

我有这门课：

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

我还有一个类扩展了

DrawItem

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

现在，在一个泛型类

CombinationGenerator

中，我试图实例化

DrawItem

/

DrawNumber

的对象。由于在java中实例化泛型类型是不可能的（比如

newe（…）

），我根据答案创建了一个工厂接口

我可以创建

CombinationGenerator

类

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

它给了我以下错误：

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

接口DrawItemFactory不能使用不同的参数实现多次：DrawItemFactory和DrawItemFactory

---

我试过这个解决办法，但我也犯了同样的错误。有没有其他方法可以做到这一点？

你可以这样做，而不是使用所有这些工厂：

public class CombinationGenerator<E> {

    E instance;

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

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

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

List<DrawNumber> combinations = generator.generate();

公共类组合生成器{
E例如；
公共组合生成器（clazz类）{
构造函数con=clazz.getConstructor（）；
this.instance=（E）con.newInstance（）；
}
}

…

---

CombinationGenerator cg=新的CombinationGenerator（DrawNumber.class）
根据@JB Nizet的评论，我通过创建两个独立的工厂类解决了这个问题，如下所示：

public class CombinationGenerator<E> {

    E instance;

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

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

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

List<DrawNumber> combinations = generator.generate();

并实例化了组合生成器，如下所示：

public class CombinationGenerator<E> {

    E instance;

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

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

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

List<DrawNumber> combinations = generator.generate();

DrawNumber DrawNumber=新的DrawNumber（）；
CombinationGenerator=new CombinationGenerator（new ItemFactory.DrawNumberFactory（））；
列表组合=generator.generate（）；
为什么要让DrawItem成为DrawItem的工厂？您需要一个DrawIem来创建DrawItem。很奇怪。使用单独的类作为工厂。谢谢。。通过创建两个独立的工厂类解决了这个问题。反射是邪恶的，它促进了对构造函数/方法签名的过于紧密的绑定，如果必要的话很难重构。简单地传递
Supplier
，然后调用
.get（）
可以提供更多的自由<代码>功能

也是一个选项。