我有几个 Java 类，它们扩展了通用 List 接口(interface)的各种实现。他们只是记录添加到列表中的任何内容。

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

我的主要目标是避免为了使用不同的基类而必须复制所有通用代码。我尽可能地坚持 DRY 原则(不要重复自己)。

首先，请不要提出更好的日志记录方式。那根本不是我真正的应用。这只是演示我遇到的问题的简单方法。

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

如下所示的 LoggingArrayList 类工作正常，但是当我将类声明从 ...extends ArrayList 更改为 ...implements List 时，对 super.method() 的三个引用不再可调用，因此我的第一个问题。

对我的第二个问题的正确回答几乎会使第一个问题变得毫无意义。第二个问题是:有没有一种方法可以声明一个抽象基类或者一个接口(interface)，它可以使用各种 add() 方法的默认实现来扩展 List，这样我就可以简单地扩展那个抽象基类或实现那个接口(interface)，并且只指定什么样的列表将成为具体类的基础？

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

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)代码。具体类可能看起来像这样，花括号内不需要额外的代码:

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

问题是我提出的接口(interface)定义是无效的(不会编译)，而且下面代码中对 super.method(s) 的引用不可用，除非我将 LoggingList 改为抽象子类一个界面，然后我马上回到现在的位置。

提前感谢您提供有关如何实现我的 DRY 目标的任何想法。

这是我的整个 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);
    }
}

最佳答案

执行此操作的一种方法是:委托(delegate)。

您可以只拥有一个，而不是为不同类型的列表拥有多个实现

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(new LinkedList()); - 但这应该没什么大不了的.. .

关于java - 如何在实现接口(interface)但不扩展另一个类的 Java 类中引用 super 方法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34084719/