Question

标题可能听起来很奇怪，但解释起来更容易：

基本上我有这个类X.这些对象总是偶数。对于这两个对象中的每一个，应该存在1个可以从它们中获取的列表。

例如，如果我创建4个X对象：A1，A2，B1，B2，我将需要有2个列表，一个只能被A1和A2攻击，另一个只能被B1和B2攻击。

提前致谢

Answer 1

您可以将2个对象和列表封装到另一个对象中吗？在此示例中，您的对象仍然是X的实例，封装类是Y：

/**
  * Encapsulates 2 X's and a List
  */
public class Y {

  private X x1;
  private X x2;
  private List list;

  public Y() {
    list = //..create list
    x1 = new X(list);
    x2 = new X(list);
  }
}

将此类与X放在同一个包中，并将X＆＃39的构造函数隐藏到包级别（默认）。如果它不是默认（无参数）构造函数（如此处所示），请编写一个私有构造函数。

Answer 2

让我改进Tim B.的答案。我也认为工厂模式是你需要的。首先，类X引用列表。

abstract class X<T> { 
  List<T> list;

  public X(List<T> l) { list = l; }
}

通过合同，所有扩展X的类都必须获取一个列表并将其移交给构造函数中的super(list)，例如

abstract class A<T> extends X<T> { 

  public A(List<T> l) { super(L); }
}
// others like B also declared similar

在工厂，我们计算＆＃34; Map<Class, List<?>>中的实例，并将相关列表交给实现。

public class Factory {

    Map<Class<?>, List<?>> class2List = new HashMap<Class<?>, List<?>(); // you may need a synchronized version here

    <T> X<T> createInstance(Class<X<T>> class) {
        List<T> list;
        // Idea: If the HashMap contains the class, we already created one instance before.
        if (class2List.contains(class)) {
            // second instance. Remove to implicitly count from 0 again
            list = (List<T>) class2List.remove(class);
        } else {
            list = new ArrayList<T>();
            class2List.add(list);
        }
        // now create the instance depending on the class and give it the list.
        // For example
        X<T> result;
        if (class.equals(A.class)) {
            result = new A<T>(list);
        } else  {
            result = new B<T>(list);
        }
        return result

    }


}

Answer 3

你可能想在这里找工厂。对工厂的一次调用会生成A和B，设置共享成员，然后在Array或某种结果对象中将它们返回给您。

Answer 4

您可以为每两个实例创建一个列表，而不是使用给定列表作为构造函数参数创建两个实例中的每一个。

每个对象只能访问其列表，因此B1，B2将使用与A1，A2不同的列表。

您可以创建一个包含姓名和列表的Map<String, List<>>。

每次创建对象时，都要从地图中获取其列表。如果它不在地图中，请创建一个新列表并将其放在那里。

共享各种字段的相同类型对象的设计模式

4 个答案: