In the previous tutorials, you have learned that objects are created from a class which is their code representation. Furthermore, each created object has its own copies of the instance variables and instance methods.

However, it is sometimes necessary to have a single copy of a variable that is shared by all objects. For example, you may need to store the total number of created Aircraft objects in a variable that would be incremented each time an object is created (each time a constructor is called). The keyword static allows you to declare such a variable. Here is an example:


totalAircrafts is declared as a static variable and, as a result, a newly created Aircraft object does not have its own copy of the variable totalAircrafts. Instead, totalAircrafts has a unique address in memory. In the example shown below, several Aircraft objects are created and the value of the variable totalAircrafts is printed to the standard output:


The output is:



Variables that are declared static can be accessed without creating an instance of the class. In the example shown above, I accessed the variable totalAircrafts directly via the name of the class:


This is the recommended way to access static variables (directly via the name of the class). I could have accessed the variable totalAircrafts via one of the instances aircraft1, aircraft2 or aircraft3:


Nonetheless, accessing static variables via instances is not recommended.

Static variables are also called class variables (as opposed to instance variables) because they are bound to the class instead of being bound to a particular instance of the class. Static fields will come in handy to declare constants that are shared by all the classes of an application. Take a look at the class AircraftConstants shown below:


The constants listed in the class AircraftConstants can be accessed from any other class via the AircraftConstants class name:


Similarly to static variables, you can declare static methods. The static method squareSurface shown below returns the surface of a square:


Generally, static methods are used as utility methods that can be called from all the classes of an application. For example, the method squareSurface shown above can be included in a class named GeometryTools which will possibly contain other utility methods:


Static methods are called via the name of the class they belong to. In other words, no instance is needed to call static methods. The class App is modified to call the method squareSurface:


The output is:


In the tutorial Hello World program, you have seen that the main method is the entry point of a Java application and it always has the same signature:


At startup (when you type java App at the command prompt), the Java virtual machine looks for that signature. At that point, there is no instance of any class from your application in memory and therefore, the Java virtual machine cannot call any method unless it is declared static. For this reason, the main method is declared static so that the Java virtual machine can execute it without needing an instance of the class App.

Note that you can use static initialization blocks in a class. You have already seen initialization blocks in the previous tutorial. A static initialization block is like a normal initialization block except that it starts with the keyword static:


The statements in a static initialization block are executed only once no matter how many instances are created. As an example, you can run the following statements:


The output is: