2

我需要创建generic list可以充当List<ClassA>或List<ClassB>因为我有以下情况。

if(e instanceof A)
return A;
else
return B

但是我想填充一个List Result可以充当List<ClassA> Resultor的对象List<ClassB> Result，我确定我们可以在这里使用泛型，但我不知道如何使用它？

更新

我想要做的就是运行时，我的列表应该填充正确的类型，要么class A or class B，

if()
{
    //data is present in List<ClassA> classAList = new ArrayList<ClassA>();
    //return classAList
}
else
{
  //return List<ClassB> classBList = new ArrayList<ClassB>();
}

希望这可以帮助。

4

8 回答 8

2

因此，如果我对您的理解正确，您希望能够根据给定对象是 ClassA 还是 ClassB 来构造 ClassA 列表或 ClassB 列表。

public List<? extends Object> getList(Object e) {
    List<? extends Object> list = new ArrayList<? extends Object>();
    if(e instanceof ClassA) {
        List<ClassA> listA = new ArrayList<ClassA>();
        // Populate list somehow
        list = listA;
    } else if (e instanceof ClassB) {
        List<ClassB> listB = new ArrayList<ClassB>();
        // Populate list somehow
        list = listB;
    }
    return list;
}

不幸的是，返回类型必须允许任何一种类型（您也可以创建两个具有不同返回类型的方法，但它们必须具有不同的名称）。但是，这允许您在将 listA 和 listB 分配给更通用的列表之前将其用作它们自己的类型。

但是，这违反了SOLID principal，因此替代方案可能是：

public abstract class Root<T> {
    public abstract List<T> getList();
}

public class ClassAList extends Root<ClassA> {
    @Override
    public List<ClassA> getList()  {
        List<ClassA> list = new ArrayList<ClassA>();
        // Populate list somehow
        return list;
    }
}

public class ClassBList extends Root<ClassB> {
    @Override
    public List<ClassB> getList()  {
        List<ClassB> list = new ArrayList<ClassB>();
        // Populate list somehow
        return list;
    }
}

希望有帮助！

于 2012-04-26T14:58:31.147 回答
1 
class A extends C{ ... body ... }
class B extends C{ ... body ... }

//将工作

List<C> list = new ArrayList<C>();
list.add(new A());
list.add(new B());

或建议Bernard

概括 ：

您的选择是创建一个父类并扩展父类A并将B 父类型添加到列表中，或者创建一个接口并实现该接口A并将B接口类型放入列表中。无论哪种方式，您最终都会更改您的类A并B创建新的接口或类

于 2012-04-26T14:43:42.933 回答
1

您应该使用两个类都实现的通用接口。假设你的接口被调用MyInterface。你的两个类都可以实现这个接口，你的泛型列表可以是 type List<MyInterface>。

另一种方法是你的两个类都有一个共同的基类。

编辑：

根据 OP 的要求添加了一些示例。

示例界面：

public interface MyInterface
{
   String getName();

   void setName(String name);
}

示例接口实现：

public class ClassA implements MyInterface
{
   private String name;

   public String getName()
   {
      return name;
   }

   public void setName(String name)
   {
      this.name = name;
   }
}

通用列表用法示例：

List<MyInterface> list = new ArrayList<MyInterface>();

list.add(new ClassA());

MyInterface item = list.get(0);

item.setName("Bob");

String name = item.getName();
于 2012-04-26T14:43:52.230 回答
0

可能是这样的：

public class Test {
  static class A {}
  static class B {}
  private static List<?> getList() {
    List<A> aList = new ArrayList<A>();
    List<B> bList = new ArrayList<B>();
    aList.add(new A());
    if (aList.size() > 0) {
      return aList;
    } else {
      return bList;
    }
  }

  public static void main(String[] args) {
    List<?> cList = getList();
    System.out.println(cList);
  }
}
于 2012-04-26T19:15:56.657 回答
0

如果 ClassA 和 ClassB 有一个共同的基类（即它们都扩展同一个类），那么您可以在泛型参数中使用基类类型。

于 2012-04-26T14:43:05.757 回答
0

泛型基本上用于静态时间检查。在您的情况下，您有两种类型的数据，因此除非 A 和 B 共享一个共同的祖先类，否则使用泛型没有任何意义

于 2012-04-26T14:43:34.523 回答
0

做到这一点的唯一方法ClassA是ClassB拥有一个公共父类或实现一个公共接口。在任何一种情况下，将列表限制为这些特定类的唯一方法是，如果没有其他类具有该公共父级或公共接口。

这两者都要求这个公共父级或公共接口已经存在，或者您可以控制ClassAand ClassB。如果他们不这样做而你不这样做，那么就没有办法做你所追求的。

于 2012-04-26T14:44:23.117 回答
0

这只有在共享一个共同的父母（比如A）时才真正可能。然后你可以返回一个.BCList<C>

可以返回 aList<Object>但我建议不要这样做并考虑重新设计您的设计。

于 2012-04-26T14:44:44.150 回答