Question

I’m developping a server application in Java. The server need two type of server classes. These classes have some methods in common, the code in these methods is exactly the same. So i create an abstract super-class containing all the shared code, and both classes are inheriting it. But, there is some part of the code that need to be precised by subclasses. I mean that the superclass “rely” on subclasses methods.

Here is a purified example of what i mean:

public abstract class AbstractServer
{
    public void loadConfig(String configPath)
    {
        //Load the configuration file.

        //This code is exactly the same for subclasses.
    }

    public void startRMI(int port)
    {
        //Create an empty RMI registry.
        //This part also need to be identical.

        //Here' where the superclass "rely" on subclasses.
        fillRegistry(); //Call the method overwritten by subclasses.
    }

    /**
    Bind remote objects in the RMI registry
    */
    protected abstract void fillRegistry(); //This method will be overriten by subclasses.
}

I feel that it’s really bad to make it like that, but i can’t find another cleaner way to do it.

So, what i want is some advice on how i could make it better.

Thanks, and sorry for my bad english.

Answer 1

Your approach is just fine. Stick with it buddy.

I feel your ‘philosophical need’ to understand it. Base class ‘relying’ on the subclass is fine as long as the base class is abstract. It knows that some things have to be registered at this point, but it doesn’t have the faintest clue about what exactly to be registered. So the high-level process is encoded in the base class with ‘holes’ that can be plugged in by the derived class. The high level process and the position of the ‘hole’ itself is valuable and this justifies the implementation of the base class. The derived classes just follow the fundamental OO principle of ‘coding by difference’ and plugs the ‘holes’.