Every object has its own copy of all the instance variables of the class. In certain cases, only one copy of a particular variable should be shared by all objects of a class. A static field—called a class variable—is used in such cases. A static
variable represents classwide information—all objects of the class share the same piece of data. The declaration of a static
variable begins with the keyword static
.
Let’s motivate static
data with an example. Suppose that we have a video game with Martian
s and other space creatures. Each Martian
tends to be brave and willing to attack other space creatures when the Martian
is aware that at least four other Martian
s are present. If fewer than five Martian
s are present, each of them becomes cowardly. Thus, each Martian
needs to know the martianCount
. We could endow class Martian
with martianCount
as an instance variable. If we do this, then every Martian
will have a separate copy of the instance variable, and every time we create a new Martian
, we’ll have to update the instance variable martianCount
in every Martian
object. This wastes space with the redundant copies, wastes time in updating the separate copies and is error prone. Instead, we declare martianCount
to be static
, making martianCount
classwide data. Every Martian
can see the martianCount
as if it were an instance variable of class Martian
, but only one copy of the static martianCount
is maintained. This saves space. We save time by having the Martian
constructor increment the static martianCount
—there’s only one copy, so we do not have to increment separate copies for each Martian
object.
Static variables have class scope. We can access a class’s public static
members through a reference to any object of the class, or by qualifying the member name with the class name and a dot (.
), as in Math.random()
. A class’s private static
class members can be accessed by client code only through methods of the class. Actually, static class members exist even when no objects of the class exist—they’re available as soon as the class is loaded into memory at execution time. To access a public static
member when no objects of the class exist (and even when they do), prefix the class name and a dot (.
) to the static
member, as in Math.PI
. To access a private static
member when no objects of the class exist, provide a public static
method and call it by qualifying its name with the class name and a dot.
A static
method cannot access non-static
class members, because a static
method can be called even when no objects of the class have been instantiated. For the same reason, the this
reference cannot be used in a static
method. The this
reference must refer to a specific object of the class, and when a static
method is called, there might not be any objects of its class in memory.