实例化泛型类并实现泛型接口 [英] Instantiating generic class and implementing generic interface

问题描述

  public DrawItem {
 protected String getSeperator（）{
 return ; 
} 
 ....... 
 //一些其他方法
} 
  

我有另外一个类，它扩展了 DrawItem 。

  public DrawNumber extends DrawItem {
 @Override 
 protected String getSeperator（）{
 return - ; 
 
 
 
 
 $ b现在，在泛型类 CombinationGenerator< E> ，我试图实例化 DrawItem  /  DrawNumber  。由于在Java中实例化泛型类型是不可能的（例如 new E（...）），所以我根据this 答案
 公共接口DrawItemFactory< E  - 代替; {
 E创建（...）; 
} 
  
然后在 CombinationGenerator< E>  class，
 
 
  public class CombinationGenerator< E> {
 DrawItemFactory< E>厂; 
 
 public CombinationGenerator< E>（DrawItemFactory< E>工厂）{
 this.factory = factory; 
} 
 
 public List< E> generate（）{
 ...... 
 list.add（factory.create（...））; 
 ...... 
} 
} 
  
现在 DrawNumber 类实现 DrawItemFactory< DrawItem> 接口。 
 
 
  public DrawItem implements DrawItemFactory< DrawItem> {
 protected String getSeperator（）{
 return; 
 
 $ b @Override 
 public DrawItem create（...）{
 return new DrawItem（...）; 
} 
 ....... 
 //一些其他方法
} 
  
我可以创建 CombinationGenerator< DrawItem>  class。 
 
 
  DrawItem drawItem = new DrawItem（...）; 
 CombinationGenerator< DrawItem> generator = new CombinationGenerator< DrawItem>（drawItem）; 
列表< DrawItem>组合= generator.generate（）; 
  
到目前为止，一切都很好。但是，当我尝试创建一个像这样的 DrawNumber 类时，
  public DrawNumber实现DrawItemFactory< DrawNumber> {
 .... 
} 
  
它给了我以下错误：  
 
 
 使用不同的参数不能多次实现接口DrawItemFactory：DrawItemFactory< DrawItem>和DrawItemFactory< DrawNumber> 
  
我试过这个解决方案，但我得到了同样的错误。有没有其他方法可以做到这一点？根据@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>厂; 
 
 public CombinationGenerator< E>（ItemFactory< E>工厂）{
 this.factory = factory; 
} 
 
 public List< E> generate（）{
 ...... 
 list.add（factory.create（...））; 
 ...... 
} 
} 
  
实例化 CombinationGenerator 像这样： 
 $ b 
  DrawNumber drawNumber = new DrawNumber（）; 
 CombinationGenerator< DrawNumber> generator = new CombinationGenerator< DrawNumber>（new ItemFactory.DrawNumberFactory（））; 
 
列表< DrawNumber>组合= generator.generate（）; 
  
 
I have this class:
public DrawItem {
    protected String getSeperator() {
        return "";
    }
    .......
    // some other methods
}
I've another class which extends DrawItem.
public DrawNumber extends DrawItem {
    @Override
    protected String getSeperator() {
        return "-";
    }
}
Now, in a generic class CombinationGenerator<E>, I'm trying to instantiate objects of DrawItem/DrawNumber. As instantiating a generic type is not possible in java (like new E(...)), I've created a Factory interface according to this answer.
public interface DrawItemFactory<E> {
    E create(...);
}
Then in the CombinationGenerator<E> class,
public class CombinationGenerator<E> {
    DrawItemFactory<E> factory;

    public CombinationGenerator<E>(DrawItemFactory<E> factory) {
        this.factory = factory;
    }

    public List<E> generate() {
        ......
        list.add(factory.create(...));
        ......
    }
}
And now the DrawNumber class implements DrawItemFactory<DrawItem> interface.
public DrawItem implements DrawItemFactory<DrawItem> {
    protected String getSeperator() {
        return "";
    }

    @Override
    public DrawItem create(...) {
        return new DrawItem(...);
    }
    .......
    // some other methods
}
And I can create CombinationGenerator<DrawItem> class.
DrawItem drawItem = new DrawItem(...);
CombinationGenerator<DrawItem> generator = new CombinationGenerator<DrawItem>(drawItem);
List<DrawItem> combinations = generator.generate();
So far, everything is fine. But when I try to create a DrawNumber class like this,
public DrawNumber implements DrawItemFactory<DrawNumber> {
     ....
}
It gives me the following error:
The interface DrawItemFactory cannot be implemented more than once with different arguments: DrawItemFactory<DrawItem> and DrawItemFactory<DrawNumber>
I've tried this solution but I got the same error. Is there any other way to do this?
解决方案
According to @JB Nizet's comment, I've solved the problem by creating two separate factory classes like this:
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);
        }           
    }
}
In the 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(...));
        ......
    }
}
And instantiated CombinationGenerator like this:
DrawNumber drawNumber = new DrawNumber();
CombinationGenerator<DrawNumber> generator = new CombinationGenerator<DrawNumber>(new ItemFactory.DrawNumberFactory());

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


                        
这篇关于实例化泛型类并实现泛型接口的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！