类型参数扩展和方法参数不匹配错误

Question

I created something like below:

ConcreteObserver1 is the subclass of IObserver

Interfaces definitions:

public interface ISubject<T,O extends IObserver<T>> {

    public void addObserver(O observer);

    public void removeObserver(O observer);

    public void updateAllSubjects(T value);

}


 public interface IObserver<T> {

    public void update(T value);

}

public class ConcreteObserver1<T> implements IObserver<T> {

Concrete Subject class containing IObserver

public class ConcreteSubject<T, O extends IObserver<T>> implements
        ISubject<T,O> {

    public ConcreteSubject() {
        addObserver(new ConcreteObserver1<T>());
    }

    ConcurrentSkipListSet<O> observersList = new ConcurrentSkipListSet<O>();

    public void addObserver(O observer) {
        observersList.add(observer);

addObserver(new ConcreteObserver1<T>()); not working.

It complains as below

The method addObserver(O) in the type ConcreteSubject is not applicable for the arguments (ConcreteObserver1)

Why ?

I told O extends IObserver<T> in ConcreteSubject type parameter definition, which says O is a sub-type of IObserver which is ConcreteObserver1

Why it is complaining.

Answer 1

The type parameter O is defined to be a subtype of IObserver<T> , this is correct. But it may stand for any subtype. You don't say anywhere that it stands for ConcreteObserver1 . It could also stand for ConcreteObserver42 or something else.

From what you posted so far, it does not seem like you really have to define O as a type parameter of ConcreteSubject . You could specifically say that ConcreteSubject always uses a ConcreteObserver1 . If this is not the case, you should probably explain your intention more clearly (and possibly, in a more readable form).

(Edited based on the comments)

interface ISubject<T,O extends IObserver<T>> 
{
    void addObserver(O observer);
    void removeObserver(O observer);
    void updateAllSubjects(T value);

}
interface IObserver<T> 
{
    void update(T value);
}

class ConcreteObserver1<T> implements IObserver<T> 
{
    @Override
    public void update(T value) {}
}
class ConcreteObserver2<T> implements IObserver<T>
{
    @Override
    public void update(T value) {}
}
class ConcreteObserver3<T> implements IObserver<T>
{
    @Override
    public void update(T value) {}
}


class ConcreteSubject<T> implements ISubject<T,IObserver<T>>
{
    ConcurrentSkipListSet<IObserver<T>> observersList =
        new ConcurrentSkipListSet<IObserver<T>>();

    public ConcreteSubject()
    {
        addObserver(new ConcreteObserver1<T>());
        addObserver(new ConcreteObserver2<T>());
        addObserver(new ConcreteObserver3<T>());
    }

    @Override
    public void addObserver(IObserver<T> observer)
    {
        observersList.add(observer);
    }

    @Override
    public void removeObserver(IObserver<T> observer)
    {
        observersList.remove(observer);
    }

    @Override
    public void updateAllSubjects(T value)
    {
        for (IObserver<T> observer : observersList)
        {
            observer.update(value);
        }
    }
}