扩展接口的所有实现的功能？

Question

我正在寻找创建一组功能，可以扩展某个接口的所有实现。 我的问题是，是否有一种方法可以不使用代理或手动扩展接口的每个实现？

我最初的想法是看是否可以使用泛型。 使用参数化类型作为实现的超级类型...

public class NewFunctionality<T extends OldFunctionality> extends T {
    //...
}

...但这是非法的。 我不知道到底为什么这是非法的，但它确实有点感觉不对，这是（可能是因为牛逼本身可能是一个接口，而不是实现）。

还有其他方法可以实现我的目标吗？

编辑我可能想做的一个例子是扩展java.util.List ...使用我狡猾的，非法的语法：

public class FilterByType<T extends List> extends T {

 public void retainAll(Class<?> c) {
  //..
 }

 public void removeAll(Class<?> c) {
  //..
 } 

}

Answer 1

您可以使用称为“装饰器”的编程模式来实现类似的功能（尽管如果接口很大，那么不幸的是，这在Java中有点冗长，因为您需要在接口中编写每个方法的单行实现） ：

public class FilterByType<T> implements List<T> {

    private List<T> _list;

    public FilterByType(List<T> list) {
        this._list = list;
    }

    public void retainAll(Class<?> c) {
        //..
    }

    public void removeAll(Class<?> c) {
        //..
    }

    // Implement List<T> interface:

    public boolean add(T element) {
        return _list.add(element);
    }

    public void add(int index, T element) {
        _list.add(index, element);
    }

    // etc...

}

另外，如果方法不需要访问受保护的成员，那么静态助手方法是一种不太麻烦的选择：

public class FilterUtils {

    public static void retainAll(List<T> list, Class<?> c) {
        //..
    }

    public static void removeAll(List<T> list, Class<?> c) {
        //..
    }

}

Answer 2

是什么阻止您仅向接口添加新方法？

如果不能仅将新功能添加到旧接口，则可以考虑创建另一个接口，然后考虑仅实现这两个接口的实现。 为了清楚起见，在代码中这就是我的意思：

// Old functionality:
public interface Traveling {
    void walk();
}
// Old implementation:
public class Person implements Traveling {
    void walk() { System.out.println("I'm walking!"); }
}
// New functionality:
public interface FastTraveling {
    void run();
    void fly();
}
// New implementation, option #1:
public class SuperHero extends Person implements FastTraveling {
    void run() { System.out.println("Zoooom!"); }
    void fly() { System.out.println("To the skies!"); }
}
// New implementation, option #2:
public class SuperHero implements Traveling, FastTraveling {
    void walk() { System.out.println("I'm walking!"); }
    void run() { System.out.println("Zoooom!"); }
    void fly() { System.out.println("To the skies!"); }
}

Answer 3

我认为这是非法的，因为您不能保证将成为T类。 还有技术上的障碍（父母的班级名称必须用字节码写，但是泛型信息会用字节码丢失）。

您可以使用Decorator模式，如下所示：

class ListDecorator implements List {
  private List decoratingList;
  public ListDecorator(List decoratingList){
    this.decoratingList = decoratingList;
  }

  public add(){
     decoratingList.add();
  }

  ...
}

class FilterByArrayList extends ListDecorator {
  public FilterByAbstractList () {
    super(new ArrayList());
  }
}

Answer 4

有一个委托/混合框架，允许使用这种形式。 您可以定义一个新接口，实现该接口的默认实现，然后请求实现该接口的类，但可以从层次结构中的其他位置获取子类。

它被称为Java的mixins ，并且那里有一个网络广播对此进行了演示。

Answer 5

恐怕不清楚您想要得到什么。

基本上，与“公共类NewFunctionality扩展OldFunctionality”相比，使用“公共类NewFunctionality <T扩展OldFunctionality>扩展T”没有任何好处（ “公共类FilterByType <T扩展List>扩展T”与“公共类FilterByType <T>实现List <T>' ）