Class implementing interface should be able to only add an object of the same class

Question

Let's say I have an interface in Java:

interface I {
    void add(I foo);
}

, and also two classes C and D that implement this interface.

Is there any way I can modify the interface such that I could only do:

C c = new C();
c.add(new C());

, but not

c.add(new D());

?

I had this question on an exam, but my only idea was to use the instanceof operator in the definition of the method:

class C implements I {
    public void add(I foo) {
        if (foo instanceof C) {
            System.out.println("instance of C");
        } else {
            System.out.println("another instance");
        }
    }
}

However, I don't know how to modify the interface such that I produce the same effect.

Thanks

Answer 1

Yes - you need generics:

interface I <T extends I<T>> {
    void add(T foo);
}

To define a class to use it, code it like this:

class C implements I<C> {
    @Override
    public void add(C foo) {
        //
    }
}

Note that there is no way to prevent the implementer from coding this (assuming D also implements I):

class C implements I<D> {
    @Override
    public void add(D foo) {
        //
    }
}

However, this would only be a problem if the coder of class C knew of the existence of class D and chose to use it, which is unlikely if they are focused on coding class C.

Even given this caveat, if I was setting this exam question, I would expect the above to be the answer.