Is it possible declare and implement a method once, but vary the return type to match subinterfaces in a robust manner?

Question

First off, I want to say there is no use case for this. The only thing I am trying to do is explore if this is possible.

What I am trying to do is "rebrand" the return signature of a method in the base interface to that of a child interface.

The goal: declare and implement a method once, but vary the return type to match subinterfaces. I have figured out how to achieve this in some cases, but it breaks down in certain situations.

Imagine if I have base interface B and it has a method B doWork(). Also, there is an implementation of B that implements doWork(). Due to the nature of doWork(), this implementation should be the only one that exists.

Now, this is pretty easy to do with Generics. For the above example:

interface B<T extends B> {
    T doWork();
}

class BImpl<T extends B> implements B<T> {
    @Override
    public T doWork() { return something; }
}

And the child interface/impl would look like this maybe:

interface C extends B<C> {
    void somethingCSpecific();
}

class CImpl extends BImpl<C> implements C {
    @Override
    public void somethingCSpecific() {   }
}

Anyone constructing CImpl would see that doWork() returns a C.

C obj = new CImpl().doWork()  // The money shot.  No casting needed.

And here is where it breaks down... Imagine B now looks like this:

public interface B<T extends B> {
    T thisOrThat(T that);
    boolean something();
}

And I want to do this in BImpl:

class BImpl<T extends B> implements B<T> {
    @Override
    public T thisOrThat(T that) {
        if (that.something())
            return that;
        return this;  //  Error!!  _this_ might be a different T than _that_.
    }
    @Override
    public boolean something()  { return whatever; }
}

Note where the error happens.

Obviously, this can't work without an unsafe and dubious cast. But if I knew that the implementation of this in the above thisOrThat method was the same as the implementation of that, everything would be ok.

So, to my question. Is there a way to restrict this and that to the same type, without knowing that type a priori?

Or maybe is there a different way to go about doing this, but having the same result? Namely only having to declare AND implement thisOrThat() just once, yet have the return type adapt to the subinterface?

Thanks.

Answer 1

Make your class BImpl abstract and add a view method to it which is implemented by the specific classes extending your abstract base class:

public abstract class BImpl<T extends B<T>> implements B<T> {
   @Override
   public T thisOrThat(T that) {
       if (that.something())
           return that;
       return this.asT();
   }


    @Override
    public boolean something() {
        // TODO Auto-generated method stub
        return false;
    }

    protected abstract T asT();
}

Every of your classes still needs to implement T asT() then, but this is simple and compiles without warning:

public class C extends BImpl<C> implements B<C> {
    @Override
    protected C asT() {
        return this;
    }
}