Question

I have this generic interface:

public interface TjbListener<T> {
    public void hearChange(T t);
}

Which I use like this:

public interface ObjectOneListener extends TjbListener<ClassOne> {

}

I would like to write an abstract generic class A which takes a generic type U as a parameter and has a method (1) which itself calls a method (2) on U. Below is my attempt U should extend (or implement maybe?) the generic TjbListener interface.

public abstract class ListenerInformer<U extends TjbListener<"what should I write here">> {
    List<U> mListeners = new ArrayList<U>();

    public void addListener(U u){
        mListeners.add(u);
    }

    public void informAll("what should I write here"){
        for(U u:mListeners){
            u.hearChange("what should I write here");
        }
    }
}

One solution I thought of as I was writing this question is below, but I don’t know if it’s really a solution, or if it has subtle problems I don’t understand:

public abstract class ListenerInformer<U extends TjbListener<T>,T> {
    List<U> mListeners = new ArrayList<U>();

    public void addListener(U u){
        mListeners.add(u);
    }

    public void informAll(T t){
        for(U u:mListeners){
            u.hearChange(t);
        }
    }
}

UPDATE: BEWARE

I have just discovered that this approach is almost useless for my particular case because the same class cannot implement the same interface with different parameters. See the question linked below. This means that I cannot have one class be a listener of two different types with my (or Johanna’s) solution, without using a different strategy like composition.

How to make a Java class that implements one interface with two generic types?

Answer 1

Your second example should work. But if it is as simple as that, then there is no need for the Generic U, because every instance of a subclass of TjbListener also is an instance of TjbListener.

You can do more simple:

public abstract class ListenerInformer<T> {
    List<TjbListener<T>> mListeners = new ArrayList<TjbListener<T>>();

    public void addListener(TjbListener<T> u){
        mListeners.add(u);
    }

    public void informAll(T t){
        for(TjbListener<T> u:mListeners){
            u.hearChange(t);
        }
    }
}

That works as your code does and is easier to handle.

Two generic types is necessary if you need the final implementation type of the subclass of TjbListener as return value of parameter, for example if you have

 public U informAll2(T t){
    for(U u:mListeners){
        u.hearChange(t);
        if (...)
            return u;
    }
}

In this case your declaration with two generic types is correct (just I’m not sure if it is possible to declare the generic U, which depends of T, before you declare T, of if you have to declare T first, like public abstract class ListenerInformer<T, U extends TjbListener<T>> )