Re: Please explain this polymorphism twist to me.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Martin schreef:
| Hi there,
|
| I discovered a strange twist in polymorphism that leaves me in the
| dark. If you can figure out what the following output will be, then
| please explain to me why.

<snip>

| "Visitor.visit(Super)"
| That means, the call "visitor.visit(this);" in the type Super is
| handled by "Visitor.visit(Super)" instead of "Visitor.visit(Sub)".
| This occurs as especially strange to me because a look in the debugger
| confirms that the actual (dynamic) type of "this" is Sub! In my
| opinion, the call should therefore be dynamically handled by
| "Visitor.visit(Sub)".
|
| I hope I didn't confuse you with Super-Sub, now, and you can tell me
| where I need to review the JLS to turn on my light again.

Yes, I stepped into this trap once as well. You need to override
accept(Visitor) in each subclass. Others have explained well why this
is so.

The proper thing to do would be: do not use overloading, then you
wouldn2"t have thought of this!

So: (note the names in Visitor)

public class OverloadTest {

~ public class Visitor {
    public void visitSuper(Super s) {
        System.out.println("Visitor.visit(Super)");
    }

    public void visitSub(Sub s) {
        System.out.println("Visitor.visit(Sub)");
    }
~ }

~ public class Super {
    public void accept(Visitor visitor) {
        visitor.visitSuper(this);
    }
~ }

~ public class Sub extends Super {
    public void accept(Visitor visitor) {
        visitor.visitSub(this);
    }
~ }

~ public static void main(String[] args) {
    OverloadTest o = new OverloadTest();
    Sub s = o.new Sub();
    s.accept(o.new Visitor());
~ }
}

Overloading is not always considered a good thing in programming
languages, and this is one of the reasons why. One can do without easily.