Re: JDK implementation of inner classes doesn't match Java Language
Specification
olafmat1@gmail.com wrote:
According to the Java Language Specification 3.0: "A nested class is
any class whose declaration occurs within the body of another class or
interface." (top of the "8. Classes" chapter), and (??8.1.3) "An inner
class is a nested class that is not explicitly or implicitly declared
static. Inner classes may not declare static initializers (??8.7) or
member interfaces. Inner classes may not declare static members,
unless they are compile-time constant fields (??15.28)."
But JDK compiler seems to use a different rule for inner classes ???
inner class seems to be a non-static class DIRECTLY enclosed by
another class.
For example the following code is invalid according to JLS,
You are mistaken. It is entirely valid according to the JDK.
but JDK accepts it:
Because it's valid.
class A {
interface B {
All member interfaces are static. [JLS ss. 8.5.2]
class C { //It's an inner class, isn't it?
No. It would only be an inner class if it were "not explicitly or implicitly
declared static". Because class 'C' is declared inside an interface, and a
"member type declaration in an interface is implicitly static and public" [JLS
ss. 9.5], 'C' is not an inner class.
static int v; //Static variable
static {} //Static initializer
static void x() {} //Static method
interface D {} //Interface
}
}
}
....
In the following code, class C has been finally recognized as an inner
class:
interface A {
class B { //Class B directly encloses C
class C {
static int v; //No error???
Are you asking if this creates an error, or stating that it didn't?
static {} //Error
static void x() {} //Error
interface D {} //Error
}
}
}
Tested on javac version 1.6.0_10-rc
Is it a bug, or did I miss something?
BTW, I don't understand why use of static members is limited at all.
Because, AIUI, an inner class needs a lexically enclosing instance of its
outer class (if not declared in a static context), but having a lexically
enclosing instance refer to a contained static member is wacky. Inner class
references exist with respect to an enclosing instance, in which context a
static member doesn't make much sense. This is my own take on the situation,
but I have yet to encounter a better explanation. Maybe another respondent
has one.
As a practical matter it's not much of a restriction, because one can just
declare static members in an outer context and it works just fine.
--
Lew