The Java Tutorial says that since an inner class is associated with an instance of the enclosing class, it (the inner class) cannot define any static members itself.
It's interesting for me why can't inner classes declare static members for instance, some private static field, which the instance of this inner class could possibly share with the other instances of the same inner class? is this just an implementation of things in Java that has to be taken for granted or something else?
Basically just an arbitrary decision. there's no reason it couldn't be supported, but there is also not really any good reason to support it. just declare the static field in the outer class.
also, that quote may not be entirely correct: i believe you can declare a static serialVersionUID in an inner class.
Update, sounds like this is now possible as of Java 16.
Because the Java Language Specification says so:
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).
As for why it was specified that way, I do not know. My guess is that inner classes were designed as small helper classes that should be very limited in complexity.
Why can't inner classes declare static members?
The inner class is contained in the instance area of the outer class. Therefore, within the inner class, it is not allowed to declare static members. On the other hand, the static inner class is contained in the static area of the outer class. Thus, it is only allowed to declare static members and not instance members.
As of Java 17, non-static inner classes can declare static members. The member is for the entire class. It doesn't matter which object instantiated it. Here is a sample program to demonstrate that.
public class Demo {
public static void main(String[] args) {
Person fred = new Person("Fred");
Person.Property p1 = fred.new Property("last name", "Flintstone");
Person wilma = new Person("Wilma");
Person.Property p2 = wilma.new Property("spouse", fred);
System.out.println(p1);
System.out.println(p2);
}
}
class Person {
private String name;
public Person(String name) { this.name = name; }
public class Property {
private static int count; // Only since Java 17
private String name;
private Object value;
public Property(String name, Object value) {
count++;
this.name = name;
this.value = value;
}
public String toString() { return "I am a property (one of " + count + ") of " + Person.this.name + " with name " + name + " and value " + value; }
}
}
The output:
I am a property (one of 2) of Fred with name last name and value Flintstone
I am a property (one of 2) of Wilma with name spouse and value Person@4e25154f
The point is one of 2. One of the Property objects belongs to fred, the other to wilma. The static variable count doesn't care. The Person.Property class has a single static count variable.
An inner class may not declare static fields unless they are compile-time constants. Hence, if you declare the static field as final it will work.
class Foo {
class Test {
final static int i = 10;
}
}
will compile and run perfectly
static fields can only be declared in static or top-level types. Hence, a (pure) static variable can be declared only in a static class.
That would result in a conflict of interest to have a static member variable inside an inner class. Generally speaking, an inner class needs to have an object instance of the outer or enclosing class before it may be instantiated. A static member variable suggests that you don't even need an object instance for that particular class, the inner class in this case, but that class the inner class is dependent upon and can only coexist along with the outer class instance. Do you see where the conflict of interest arises in the argument? However, you can make a static member variable inside an inner class by declaring the inner class as static which means the inner class no longer needs to coexist with an outer class object.
public class A {
public static class B {
private static JPanel myJPanel;
}
}
