扩展一个 java ArrayList

Question

我想扩展 ArrayList 为特定类添加一些方法，该类的实例将由扩展的 ArrayList 保存。下面是一个简化的说明性代码示例。

这对我来说似乎很明智，但我对 Java 还是很陌生，而且我看到了其他不鼓励扩展 ArrayList 的问题，例如 Extending ArrayList and Creating new methods。我对 Java 的了解不够，无法理解这些反对意见。

在我之前的尝试中，我最终在 ThingContainer 中创建了许多方法，这些方法本质上是传递给 ArrayList，因此扩展似乎更容易。

有没有更好的方法来做我想做的事情？如果有，应该如何实施？

import java.util.*;

class Thing {
    public String name;
    public int amt;

    public Thing(String name, int amt) {
        this.name = name;
        this.amt = amt;
    }

    public String toString() {
        return String.format("%s: %d", name, amt);
    }

    public int getAmt() {
        return amt;
    }
}

class ThingContainer extends ArrayList<Thing> {
    public void report() {
        for(int i=0; i < size(); i++) {
            System.out.println(get(i));
        }
    }

    public int total() {
        int tot = 0;
        for(int i=0; i < size(); i++) {
            tot += ((Thing)get(i)).getAmt();
        }
        return tot;
    }

}

public class Tester {
    public static void main(String[] args) {
        ThingContainer blue = new ThingContainer();

        Thing a = new Thing("A", 2);
        Thing b = new Thing("B", 4);

        blue.add(a);
        blue.add(b);

        blue.report();
        System.out.println(blue.total());

        for (Thing tc: blue) {
            System.out.println(tc);
        }
    }
}

Answer 1

该答案中没有任何内容不鼓励扩展 ArrayList；存在语法问题。类扩展存在，因此我们可以重用代码。

对扩展类的一般反对意见是"favor composition over inheritance" 讨论。扩展并不总是首选机制，但这取决于您实际在做什么。

根据要求编辑合成示例。

public class ThingContainer implements List<Thing> { // Or Collection based on your needs.
    List<Thing> things;
    public boolean add(Thing thing) { things.add(thing); }
    public void clear() { things.clear(); }
    public Iterator<Thing> iterator() { things.iterator(); }
    // Etc., and create the list in the constructor
}

您不一定需要公开一个完整的列表界面，只公开一个集合，或者根本不公开。但是，不公开任何功能会大大降低一般用途。

在 Groovy 中，您可以使用 @Delegate 注释自动构建方法。 Java 可以使用Project Lombok 的@Delegate 注释来做同样的事情。我不确定 Lombok 将如何公开界面，或者是否公开。

我在使用 Glowcoder，在这种情况下，我认为扩展没有任何根本性的问题——这实际上是哪种解决方案更适合该问题的问题。

编辑以获取有关继承如何违反封装的详细信息

有关详细信息，请参阅 Bloch 的 Effective Java，第 16 条。

如果子类依赖于超类的行为，而超类的行为发生变化，则子类可能会中断。如果我们不控制超类，这可能会很糟糕。

这是一个具体的例子，取自书中（对不起，乔希！），用伪代码和大量解释（所有错误都是我的）。

class CountingHashSet extends HashSet {
    private int count = 0;
    boolean add(Object o) {
        count++;
        return super.add(o);
    }
    boolean addAll(Collection c) {
        count += c.size();
        return super.addAll(c);
    }
    int getCount() { return count; }
}

然后我们使用它：

s = new CountingHashSet();
s.addAll(Arrays.asList("bar", "baz", "plugh");

然后它返回......三个？没有。六。为什么？

HashSet.addAll() 在HashSet.add() 上实现，但这是一个内部实现细节。我们的子类addAll() 增加了三个，调用super.addAll()，它调用add()，这也增加了计数。

我们可以删除子类的addAll()，但现在我们依赖于超类的实现细节，这可能会改变。我们可以修改我们的addAll() 以迭代并在每个元素上调用add()，但现在我们正在重新实现超类行为，这违背了目的，并且如果超类行为依赖于对私有成员的访问，可能并不总是可行。

或者超类可能实现了我们的子类没有的新方法，这意味着我们类的用户可能会通过直接调用超类方法无意中绕过预期的行为，因此我们必须跟踪超类 API 以确定何时以及是否，子类应该改变。

Answer 2

这是我的建议：

interface ThingStorage extends List<Thing> {
    public int total();
}

class ThingContainer implements ThingStorage {

    private List<Thing> things = new ArrayList<Thing>();

    public boolean add(Thing e) {
        return things.add(e);
    }

    ... remove/size/... etc     

    public int total() {
        int tot = 0;
        for(int i=0; i < size(); i++) {
            tot += ((Thing)get(i)).getAmt();
        }
        return tot;
    }

}

实际上不需要report()。 toString() 可以完成剩下的工作。

Answer 3

我不认为扩展 arrayList 是必要的。

public class ThingContainer {

    private ArrayList<Thing> myThings;

    public ThingContainer(){
        myThings = new ArrayList<Thing>();
    }

    public void doSomething(){
         //code
    }

    public Iterator<Thing> getIter(){
        return myThings.iterator();
    }
}

您应该将 ArrayList 包装在您的 ThingContainer 类中。 ThingContainer 然后可以有你需要的任何处理方法。无需扩展 ArrayList；只保留一个私人成员。 希望这会有所帮助。

您可能还想考虑创建一个代表您的事物类的接口。这为您提供了更大的可扩展性灵活性。

public Interface ThingInterface {
   public void doThing();
}

...

public OneThing implements ThingInterface {
   public void doThing(){
        //code
   }
}

public TwoThing implements ThingInterface {
   private String name;
   public void doThing(){
        //code
   }
}