javablogspot

Just another WordPress.com weblog

The Ultimate Java Puzzler

Posted by damuchinni on February 16, 2009

Why is this particular one the ultimate? Two reasons:

* It’s at the very core of the Java language, not some obscure piece of API.
* It melted my brain when I hit it.

Let’s start by setting up the puzzler environment. We’ll have three classes in two packages. Classes C1 and C2 will be in package p1:
PLAIN TEXT
JAVA:

1.
package p1;
2.
public class C1 {
3.
public int m() {return 1;}
4.
}
5.
public class C2 extends C1 {
6.
public int m() {return 2;}
7.
}

Class C3 will be in a separate package p2:
PLAIN TEXT
JAVA:

1.
package p2;
2.
public class C3 extends p1.C2 {
3.
public int m() {return 3;}
4.
}

We will also have the test class p1.Main with the following main method:
PLAIN TEXT
JAVA:

1.
public static void main(String[] args) {
2.
C1 c = new p2.C3();
3.
System.out.println(c.m());
4.
}

Note that we’re calling the method of C1 on an instance of C3. The output for this example is “3″ as you’d expect. Now let’s change the m() visibility in all three classes to default:
PLAIN TEXT
JAVA:

1.
public class C1 {
2.
/*default*/ int m() {return 1;}
3.
}
4.
public class C2 extends C1 {
5.
/*default*/ int m() {return 2;}
6.
}
7.
public class C3 extends p1.C2 {
8.
/*default*/ int m() {return 3;}
9.
}

The output will now be “2″!

Why is that? The Main class that invokes the method does not see the m() method in the C3 class, it being in a separate package. As far as it cares the chain ends with C2. But as C2 is in the same package it overrides the m() method in C1. This does not seem too intuitive, but that’s the way it is.

Now let’s try something different, let’s change the modifier of C3.m() back to public. What will that do?
PLAIN TEXT
JAVA:

1.
public class C1 {
2.
/*default*/ int m() {return 1;}
3.
}
4.
public class C2 extends C1 {
5.
/*default*/ int m() {return 2;}
6.
}
7.
public class C3 extends p1.C2 {
8.
public int m() {return 3;}
9.
}

Now Main can clearly see the C3.m() method. But amazingly enough output is still “2″!

Apparently C3.m() is not considered to override C2.m() at all. One way to think about it is overriding methods should have access to the super methods (via super.m()). However in this case C3.m() wouldn’t have access to its super method, as it it not visible to it, being in another package. Therefore C3 is considered to be in a completely different invocation chain from C1 and C2. Were we to call C3.m() directly from Main the output would actually be “3″.

Now let’s look at one last example. Protected is an interesting visibility. It behaves like default for members in the same package and like public for subclasses. What will happen if we change all of the visibilities to protected?
PLAIN TEXT
JAVA:

1.
public class C1 {
2.
protected int m() {return 1;}
3.
}
4.
public class C2 extends C1 {
5.
protected int m() {return 2;}
6.
}
7.
public class C3 extends p1.C2 {
8.
protected int m() {return 3;}
9.
}

My reasoning goes like this: as Main is not a subclass of any classes protected should behave as default in this case and output should be “2″. However that is not the case. The crucial thing is that C3.m() has access to super.m() and thus the actual output will be “3″.

Personally, when I first encountered this accessibility issue I got thoroughly confused and couldn’t get it until I did all of this examples through. The intuition I got from this is that if and only if you can access super.m() the subclass is a part of the invocation chain. But for the kicker try reading all of this out from the JVM specification that selects the method to be invoked:

Let C be the class of objectref. The actual method to be invoked is selected by the following lookup procedure:

* If C contains a declaration for an instance method with the same name and descriptor as the resolved method, and the resolved method is accessible from C, then this is the method to be invoked, and the lookup procedure terminates.
* Otherwise, if C has a superclass, this same lookup procedure is performed recursively using the direct superclass of C; the method to be invoked is the result of the recursive invocation of this lookup procedure.
* Otherwise, an AbstractMethodError is raised

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: