Question

I’m looking to create a set of functions which all implementations of a certain Interface can be extended to use. My question is whether there’s a way to do this without using a proxy or manually extending each implementation of the interface?

My initial idea was to see if it was possible to use generics; using a parameterized type as the super type of my implementation…

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

…but this is illegal. I don’t exactly know why this is illegal, but it does sort of feel right that it is (probably because T could itself be an interface rather than an implementation).

Are there any other ways to achieve what I’m trying to do?

EDIT One example of something I might want to do is to extend java.util.List… Using my dodgy, illegal syntax:

public class FilterByType<T extends List> extends T {

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

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

}

Answer 1

You can achieve something like this using a programming pattern known as a ‘decorator’ (although if the interface is large then unfortunately this is a bit verbose to implement in Java because you need to write single-line implementations of every method in the interface):

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...

}

Alternatively, if the methods don’t need to access protected members, then static helper methods are a less clucky alternative:

public class FilterUtils {

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

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

}