CODEWITHSUNDEEP
javapolymorphism
Leonide
Leonide

Reputation: 245

Downcasting and polymorphism without using instanceof? (Java)

Here's the sort of thing I'm trying to do:

class Foo {
    private ArrayList<Widget> things; //Contains WidgetA, WidgetB and WidgetAB objects
    //...
    void process(int wIndex) {
       process(things.get(wIndex);
    }

    private void process(WidgetA w) {
       //Do things
    }
    private void process(WidgetB w) {
       //Do other things
    }
    private void process(WidgetAB w) {
       //Do completely different things
    }
}

abstract class Widget {
    //...
}

class WidgetA extends Widget {
    //...
}
class WidgetB extends Widget {
}
class WidgetAB extends WidgetA {
}

Basically, a separate class gets an array index from user input, and passes it to the process(int) method, which is supposed to kick off a type-specific process() method to process the object at the passed index. The problem is that the objects are treated as Widget objects, not WidgetA, etc. I could loop through the types using instanceof, I guess, but I'm trying to avoid using that. The logic in the process() methods needs to access private fields in the Foo class, so moving them to the Widget subclasses might not be the best idea.

So the question is, is there a way for the correct process() method to be called for a given Widget subtype, without using instanceof?

Upvotes: 2

Views: 916

Answers (2)

FGreg
FGreg

Reputation: 15330

Another potential solution is to use Java's reflection API's. Example:

class Foo {
    private ArrayList<Widget> things; //Contains WidgetA, WidgetB and WidgetAB objects
    //...
    void process(int wIndex) {
        Widget theWidget = things.get(wIndex);
        try {
            Class type = theWidget.getClass();
            Class[] arg_types = new Class[]{type};
            this.getMethod("process", arg_types).invoke(this, theWidget);
        } catch (Exception e) {
            //Could be SecurityException or NoSuchMethodException
        }
    }

    private void process(WidgetA w) {
       //Do things
    }
    private void process(WidgetB w) {
       //Do other things
    }
    private void process(WidgetAB w) {
       //Do completely different things
    }
}

abstract class Widget {
    //...
}

class WidgetA extends Widget {
    //...
}
class WidgetB extends Widget {
}
class WidgetAB extends WidgetA {
}

The issue here being that you have to have defined a process() method for each type of object in the things list or an exception will be thrown at run-time. The compiler will not warn you if you are missing an implementation.

Upvotes: 0

duffymo
duffymo

Reputation: 308868

Yes, have a look at the Visitor pattern - also known as double dispatch.

Upvotes: 3

Related Questions