Why an outer Java class can’t be static
Published: 2019-12-24 14:11:29

[In a previous blog](https://programmingmitra.com/2016/10/why-a-java-class-can-not-be-private-or-protected.html), I talked about why we can not define an outer class using private or protected keywords. If you have not read it, please go ahead and give it a look.  
  
In this article I will talk what is the use of the static keyword, why an outer Java class can’t be static, why it is not allowed in Java to define a static outer class. In order to understand that first, we need to understand what is the static keyword used for, what purpose it solves and how does it work.  
  

#### What does static keyword do

Every Java programmer knows that if we need to define some behaviour (method) or state (field) which will be common to all objects we define it as static. Because static content (behaviour or state) does not belong to any particular instance or object, it will common to all objects and all objects are free to change any static field and every change will be visible to every object.  
  
We do not need to create an object of the class to access a static field or method, we can directly refer a static field or method by using class name and dot operator e.g. Class.forName(“ClassName”).  
This happens because JVM creates a Class level object for every class when Classloader loads the class into memory. And all static content of that class belongs this Class object and all other objects of that class refer to this class level object for all static content. A class-level object is actually an object of java.lang.Class and it is referred by your\_class\_name.class syntax.  
  
For Example for the below statement, two objects will get created  
  

    Employee emp =  new Employee();
    

  
One is ‘emp’ (the new Employee();) itself and another one is the ‘class level object’ of Employee class which will get created while JVM will load Employee class into memory and we can refer it by Employee.class. And this class level object holds all the static content of the Employee class either it is a variable or method. If we are accessing any static content through emp object it automatically points to Employee.class object to access that.  
  
That is the reason why a static variable got changed for every object even if we change it for a single emp object because all emp objects are pointing same copy of that variable from Employee.class object, for more information read [Why Java is Purely Object-Oriented Language Or Why Not](https://programmingmitra.com/2016/06/why-java-is-purely-object-oriented-or-why-not.html).  
  

#### Why an outer Java class can’t be static

From above we can conclude that we should define members as static which  

1.  Should be common to all objects of the class.
2.  Should belong to the class and accessible by class name.
3.  Should not need an object of a class to access them.

Now suppose we are defining an outer class as static and suppose we are allowed to do so. Will this serve any purpose or provide any advantage to a developer or it will create ambiguity and complications for both developers and language creators?  
  
Let’s check, defining an outer class as static will serve purposes which we have defined above or not?  

1.  Every class is already common to all of its objects and there is no need to make it static to become available to all of its objects.
2.  We need a class name to access its static members because these members are part of class while an outer class is part of the package and we can directly access the class by just writing package\_name.class\_name (similar to class\_name.static\_field\_name), So again there is no need to do which is already there by default.
3.  We do not need any object to access a class if it is visible, we can simply write package\_name.class\_name to access it. And by definition, a class is a blueprint for its objects and we create a class to create objects from it (exception will always be there e.g. java.lang.Math), again there is no need to define an outer class as static.

From the above points, we can say Java creators had not allowed an outer class to be static because there is no need to make it static. Allowing to make the outer class static will only increase complications, ambiguity and duplicity.