如何在实现接口但不扩展另一个类的Java类中引用超级方法？

Question

我有几个Java类，它们扩展了泛型列表接口的各种实现。它们只需记录添加到列表中的任何内容。

LoggingArrayList如下所示。顾名思义，它扩展了ArrayList。LoggingLinkedList类完全相同，只是它扩展了LinkedList。

我的主要目标是避免重复所有的公共代码，这样我就可以使用不同的基类。我在尽量坚持干巴巴的原则（不要重复你自己）。

首先，请不要建议更好的登录方式。那根本不是我真正的申请。这只是一个简单的方法来演示我的问题。

我有两个密切相关的问题。第一个是题目中的问题。如何在实现接口但不扩展另一个类的Java类中引用“超级”方法？

如下所示的LoggingArrayList类工作良好，但当我将类声明从...extends ArrayList更改为...implements List时，对super.method（）的三个引用就不再可以调用，这就是我的第一个问题。

对我的第二个问题的一个好的回答几乎会使第一个问题变得没有意义。第二个问题是这样的：有没有一种方法可以声明一个抽象基类或者一个接口，它可以通过各种add（）方法的默认实现来扩展List，这样我就可以简单地扩展这个抽象基类或者实现那个接口，并且只指定什么类型的List将是具体类的基础？

例如，我想做这样的事情：

interface LoggingList<T extends Object, L extends List<T>> extends L
{
    // overloaded methods go here as shown below 
    //  with overloaded methods declared as default for the interface
}

...然后我可以简单地为List的每个具体实现实现一次LoggingList，而不重复所有的公共代码。具体的类可能看起来像这样，在它们的花括号内不需要额外的代码：

public class LoggingArrayList<T extends Object> implements LoggingList<T, ArrayList<T>> {}
public class LoggingLinkedList<T extends Object> implements LoggingList<T, LinkedList<T>> {}

问题是，我所提出的接口定义是无效的（无法编译），而且，下面所示代码中对super.method的引用是不可用的，除非我将LoggingList变成一个抽象子类而不是接口，然后我就回到了现在的位置。

提前感谢任何关于如何完成我的干燥目标的想法。

这是我的整个LoggingArrayList类。

public abstract class LoggingArrayList<T extends Object>
    extends ArrayList<T>
{
    protected void log(T e)
    {
        System.out.println(e == null ? "null" : e.toString());
    }

    @Override
    public boolean add(T e) {
        log(e);
        // How do I reference a super.method()
        // in a class that implements an interface
        // but does not extend another class?
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends T> clctn) {
        boolean anyChanges = false;
        for(T e : clctn)
        {
            // ensure that we call our overridden version of add()
            //  so it gets logged.
            anyChanges = anyChanges || add(e);
        }
        return anyChanges;
    }

    @Override
    public boolean addAll(int i, Collection<? extends T> clctn) {
        for(T e : clctn)
        {
            // ensure that we call our overridden version of add() 
            //  so it gets logged.
            add(i, e);
            i++; // keep the inserted elements in their original order
        }
        return !clctn.isEmpty();
    }

    @Override
    public T set(int i, T e) {
        log(e);
        // How do I reference a super.method()
        // in a class that implements an interface
        // but does not extend another class?
        return super.set(i, e);
    }

    @Override
    public void add(int i, T e) {
        log(e);
        // How do I reference a super.method()
        // in a class that implements an interface
        // but does not extend another class?
        super.add(i, e);
    }
}

Answer 1

曾经的方法是：委派。

您可以只使用一个实现，而不是为不同类型的列表提供多个实现

public class LoggingList<T extends Object> implements List<T>

  protected List<T> superList;

  public LoggingList(List<T> anotherList) {
     superList= anotherList;
  }

  protected void log(T e) {
      System.out.println(e == null ? "null" : e.toString());
  }

  @Override
  public boolean add(T e) {
      log(e);
      return superList.add(e);
  }

然后调用super.而不是调用superlist.

您仍然必须将构造函数从new LoggingLinkedList()调整为new LoggingList()-但这应该不是什么大事...