Obtaining the original Java class while using instanceof and casting

Question

First off, for anyone out there who abhors, detests and despises the instanceof operator, I understand your concerns with it, but am stuck using it. That's because I don't have the authority to completely refactor the way another development team set a project up, so unless I'm missing somethin here, I just don't see any way of avoiding it.

I have a Java POJO that cannot be changed, and allows you to set an Exception as one of its properties:

public class Message {
    private Exception exception;

    public void setException(Exception exc) {
        this.exception = exc;
    }
}

Again, I can't change this Message class.

I am writing an error handler method that gets passed a MessageContainer instances, and I need logic to do different things depending on what type of exception was set on the container's Message:

public class ErrorHandler {
    public void handle(MessageContainer container) {
        Message msg = container.getMessage();
        Exception exc = msg.getException();

        if(exc instanceof FizzException)
            System.out.println("Do x");
        else if(exc instanceof BuzzException)
            System.out.println("Do y");
        else
            System.out.println("Do z");
    }
}

Again, I can't change the fact that ErrorHandler#handle is passed a MessageContainer and not an injectable Message instance.

So, even though I really don't like to use instanceof, I don't see any other way of accomplishing this logic (but by all means, please make suggestions...as long as they don't involve making changes to Message, MessageContainer, or the handle(MessageContainer) method!).

But even with using instanceof, how does this code even work? Once you pull the Exception out of the Message, I don't think any of the instanceofs will fire, because its cast to an Exception, with no way to detect if it's BuzzException, FizzException, etc. What are my options here? Thanks in advance.

Bastien Jansen · Accepted Answer · 2013-01-25 19:07:27Z

3

This code will work as expected. During runtime, instanceof statements will compare the actual type of exc, and not just assume this is only an Exception. If the only statement that worked was exc instanceof Exception, instanceof would be totally worthless :)

Another solution (which I would avoid to use) would be to compare fully qualified class names:

String fqcn = exc.getClass().getName();

if (fqcn.equals("com.foo.FizzException") {
    // etc.
}

edited Jan 25, 2013 at 19:07

answered Jan 25, 2013 at 18:47

Bastien Jansen

8,8462 gold badges39 silver badges55 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Nathan Hughes Over a year ago

the last bit won't work because it will dispatch on the compile-time type, not on the runtime type of the variable.

Alpedar Over a year ago

+1 for first part -1 for second, it will not work, as Nathan Hughes ^^ says.

Philipp Over a year ago

@NathanHughes is right. I just wrote this little test program: pastebin.com/TiZJXrXs in all four cases, it calls the method for Object.

Bastien Jansen Over a year ago

You're right, I forgot this. I removed the last part from my answer.

Nathan Hughes · Accepted Answer · 2013-01-25 19:03:59Z

1

The cast to exception on

Exception exc = msg.getException();

does not erase the exception runtime type. It has merely cast it to a base type. The instanceof will still work. However, if your FizzException extends BuzzException, then you will need to do the instanceof checks in the other order. i.e. check for the most derived type first.

Otherwise, it will go into the base class check clause instead of the derived one.

edited Jan 25, 2013 at 19:03

Nathan Hughes

96.7k21 gold badges193 silver badges288 bronze badges

answered Jan 25, 2013 at 18:49

drone-ah

1,15314 silver badges29 bronze badges

Comments

Hot Licks · Accepted Answer · 2013-01-25 19:04:12Z

1

It's not clear what you want. If the exceptions are all "given" and you can't change their implementations then you can use exception.getClass().getName() to get the class name and, maybe, look it up in a table or whatever to pick your course of action.

If you can change many of the exception implementations have them all implement an interface that provides a "functionality()" method or whatever. If an given Exception object is instanceof MyFunctionalityInterface then cast to MyFunctionalityInterface and call functionality() to have it return the info you need to guide your actions. Then use instanceof or getClass().getName() to manage the Exception classes you can't change.

answered Jan 25, 2013 at 19:04

Hot Licks

47.8k19 gold badges96 silver badges156 bronze badges

Collectives™ on Stack Overflow

Obtaining the original Java class while using instanceof and casting

3 Answers 3

4 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related