Benefits of Using Generics in a Base Class that Also Implement the Same Class

Question

I recently ran across this scenario in code that I didn't write and while there may be some design benefit to this approach, I can't seem to squeeze this rationale out of my own brain. So before I go and look foolish, I'm hoping for some feedback here.

Service interface something like this:

public interface Service {...}

Then, a base class that adds a generic reference to the Service interface where T extends the Service, but then the overall base class also implements the interface. Something like this:

public class ServiceBase<T extends Service> implements Service {...}

Why would you do this? I'm noticing that in practice the extension of ServiceBase always uses the same class name as T as the one that is being declared; so there's not really any magic polymorphic benefit here. Something like this:

public class MyService extends ServiceBase<MyService> {...}

and, the MyService class is never a container for the generic (e.g., I don't believe this is signaling some kind of self-containing list, where MyService could contain a list of MyServices).

Any ideas/thoughts on why someone would do this?

Answer 1

Why would you do this? I'm noticing that in practice the extension of ServiceBase always uses the same class name as T as the one that is being declared; so there's not really any magic polymorphic benefit here.

Generics don't exist to create magic polymorphim. It is mainly a way to add constraints on types at compile time in order to reduce clumsy cast and error type at runtime.

In your case, suppose that ServiceBase class is abstract and has a process() method which needs to create at each call a new instance of the concrete class we declare in the parameterized type.
We call this abstract method createService().

Without using generics, we could declare the method like that public abstract ServiceBase createService().

ServiceBase without generics

public abstract class ServiceBase implements Service {

    public abstract ServiceBase createService();

    @Override
    public void process() {
         createService().process();
    }

}

With this declaration, the concrete class may return any instance of ServiceBase.

For example, the following child class will compile because we are not forced to change the returned type of createService() to the current declared type.

MyService without generics

public class MyService extends ServiceBase {

    @Override
    public ServiceBase createService() {    
        return new AnotherService();
    }

}

But if I use generics in base class :

ServiceBase with generics

public abstract class ServiceBase<T extends Service> implements Service {

    public abstract T createService();

    @Override
    public void process() {
         createService().process();
    }

}

The concrete class has no choice, it is forced to change the returned type of createService() with the parameterized type declared.

MyService with generics

public class MyService extends ServiceBase<MyService> {

    @Override
    public MyService createService() {  
        return new MyService();
    }

}