Question

我正在寻找一组函数，可以扩展某个接口的所有实现以供使用。我的问题是，是否有办法没有使用代理或手动扩展接口的每个实现？

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

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

......但这是非法的。我不完全知道为什么这是非法的，但它确实感觉它是正确的（可能因为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

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

它被称为mixins for Java，并且有一个网络广播就可以演示它。

Answer 5

我担心你不清楚你想得到什么。

基本上，我认为使用 '公共类NewFunctionality＆lt; T extends OldFunctionality＆gt;没有任何好处。扩展T' 与 '公共类相比，NewFunctionality扩展OldFunctionality' （ '公共类FilterByType＆lt; T扩展List＆gt ;扩展T' vs '公共类FilterByType＆lt; T＆gt;实现List＆lt; T＆gt;' ）

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

5 个答案: