Why does Java prohibit static fields in inner classes?

Why does Java prohibit static fields in inner classes?

class OuterClass {   class InnerClass {    static int i = 100; // compile error    static void f() { } // compile error   }  }   

Although it's not possible to access the static field with OuterClass.InnerClass.i, if I want to record something that should be static, e.g. the number of InnerClass objects created, it would be helpful to make that field static. So why does Java prohibit static fields/methods in inner classes?

EDIT: I know how to make the compiler happy with static nested class (or static inner class), but what I want to know is why java forbids static fields/methods inside inner classes (or ordinary inner class) from both the language design and implementation aspects, if someone knows more about it.

Thanks.

Answer by Asaph for Why does Java prohibit static fields in inner classes?

InnerClass cannot have static members because it belongs to an instance (of OuterClass). If you declare InnerClass as static to detach it from the instance, your code will compile.

class OuterClass {      static class InnerClass {          static int i = 100; // no compile error          static void f() { } // no compile error      }  }  

BTW: You'll still be able to create instances of InnerClass. static in this context allows that to happen without an enclosing instance of OuterClass.

Answer by Gregory Pakosz for Why does Java prohibit static fields in inner classes?

The idea behind inner classes is to operate in the context of the enclosing instance. Somehow, allowing static variables and methods contradicts this motivation?

8.1.2 Inner Classes and Enclosing Instances

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).

Answer by OscarRyz for Why does Java prohibit static fields in inner classes?

I want to know why java forbids a static filed/method inside inner class

Because those inner classes are "instance" inner classes. That is, they are like an instance attribute of the enclosing object.

Since they're "instance" classes, it doesn't make any sense to allow static features, for static in meant to work without an instance in first place.

Is like you try to create an static/instance attribute at the same time.

Take the following example:

 class Employee {       public String name;   }  

If you create two instances of employee:

Employee a = new Employee();   a.name = "Oscar";    Employee b = new Employee();  b.name = "jcyang";  

It is clear why each one has its own value for the property name right?

The same happens with the inner class, each inner class instance is independent of other inner class instance.

So if you attempt to create a counter class attribute, there is no way to share that value across two different instances.

class Employee {      public String name;      class InnerData {          static count; // ??? count of which ? a or b?        }  }  

When you create the instance a and b in the example above, what would be a correct value for the static variable count? It is not possible to determine it, because the existence of the InnerData class depends completely on each of the enclosing objects.

That's why, when the class is declared as static, it doesn't needs anymore an living instance, to live it self. Now that there is no dependency, you may freely declare an static attribute.

I think this sounds reiterative but if you think about the differences between instace vs. class attributes it will make sense.

Answer by user3387322 for Why does Java prohibit static fields in inner classes?

Actually, you can declare static fields if they are constants and are written in compile time.

class OuterClass {      void foo() {          class Inner{              static final int a = 5; // fine              static final String s = "hello"; // fine              static final Object o = new Object(); // compile error, because cannot be written during compilation          }      }  }  

Answer by ianos for Why does Java prohibit static fields in inner classes?

Here is the motivation that I find best suitable for this "limit": You can implement the behavior of a static field of an inner class as an instance field of the outer object; So you do not need static fields/methods. The behaviour I mean is that all inner class instances of some object share a field(or method).

So, suppose you wanted to count all the inner class instances, you would do:

public class Outer{      int nofInner; //this will count the inner classes of this object                    //(you know, they "belong" to an object)      static int totalNofInner; //this will count all                                 //inner classes of all Outer objects      class Inner {          public Inner(){              nofInner++;              totalNofInner++;          }      }  }  

Fatal error: Call to a member function getElementsByTagName() on a non-object in D:\XAMPP INSTALLASTION\xampp\htdocs\endunpratama9i\www-stackoverflow-info-proses.php on line 72