Question

So, in a single parent inheritance model what’s the best solution for making code extensible for future changes while keeping the same interface (I’d like to emphasize the fact that these changes cannot be known at the time of the original implementation, the main focus of my question is to explore the best mechanism/pattern for supporting these changes as they come up)? I know that this is a very basic OO question and below I provide example of how I’ve been going about it, but I was wondering if there a better solution to this common problem.

Here’s what I’ve been doing (the example code is in Java):

In the beginning, the following two classes and interface are created:

public class Foo
{
    protected int z;
}

public interface FooHandler
{
    void handleFoo(Foo foo);
}

public class DefaultFooHandler implements FooHandler
{
    @Override
    public void handleFoo(Foo foo)
    {
        //do something here
    }
}

The system uses variables/fields of type FooHandler only and that object (in this case DefaultFooHandler) is created in a few, well-defined places (perhaps there’s a FooHandlerFactory) so as to compensate for any changes that might happen in the future.

Then, at some point in the future a need to extend Foo arises to add some functionality. So, two new classes are created:

public class ImprovedFoo extends Foo
{
    protected double k;
}

public class ImprovedFooHandler extends DefaultFooHandler
{
    @Override
    public void handleFoo(Foo foo)
    {
        if(foo instanceof ImprovedFoo)
        {
            handleImprovedFoo((ImprovedFoo)foo);
            return;
        }
        if(foo instanceof Foo)
        {
            super.handleFoo(foo);
            return;
        }
    }

    public void handleImprovedFoo(ImprovedFoo foo)
    {
        //do something involving ImprovedFoo
    }
}

The thing that makes me cringe in the example above is the if-statements that appear in ImprovedFooHandler.handleFoo

Is there a way to avoid using the if-statements and the instanceof operator?

Answer 1

First of all the code you wrote won’t work.
Each time you see instanceof and if...else together be very careful. The order of these checks is very important. In your case you’ll never execute handleImpovedFoo. Guess why 🙂

It’s absolutely normal you have these instanceof statements. Sometimes it’s the only way to provide different behavior for a subtype.
But here you can use another trick: use simple Map. Map classes of foo-hierarchy to instances of fooHandler-hierarchy.

Map<Class<? extends Foo>, FooHandler> map ...

map.put( Foo.class, new FooHandler() );
map.put( ImprovedFoo.class, new ImprovedFooHandler() );

Foo foo ...; // here comes an unknown foo 

map.get( foo.getClass() ).handleFoo( foo );