Understanding Static Fields and Methods

According to my handy Webster’s dictionary, the word static has several meanings, most of which relate to the idea of being stationary or unchanging. A static display is a display that doesn’t move. Static electricity is an electrical charge that doesn’t flow. A static design is a design that doesn’t change.

As used by Java, however, the term static doesn’t mean unchanging. You can create a static field, for example, and then assign values to it as a program executes. Thus, the value of the static field can change.

To confuse things further, the word static can also mean interference, as in radio static that prevents you from hearing music clearly on the radio. But in Java, the term static doesn’t have anything to do with interference or bad reception.

So what does the term static mean in Java? It’s used to describe a special type of field or method that isn’t associated with a particular instance of a class. Instead, static fields and methods are associated with the class itself, which means that you don’t have to create an instance of the class to access a static field or methods. Instead, you access a static field or method by specifying the class name, not a variable that references an object.

The value of a static field is the same across all instances of the class. In other words, if a class has a static field named CompanyName , all objects created from the class will have the same value for CompanyName .

Static fields and methods have many common uses. Here are but a few:

To provide constants or other values that aren’t related to class instances: A Billing class might have a constant named SALES_TAX_RATE that provides the state sales tax rate.
To keep count of how many instances of a class have been created: A Ball class used in a game might have a static field that counts how many balls currently exist. This count doesn’t belong to any one instance of the Ball class.
In a business application, to keep track of a reference or serial number that’s assigned to each new object instance: An Invoice class might maintain a static field that holds the invoice number that is assigned to the next Invoice object created from the class.
To provide an alternative way to create instances of the class: An excellent example is the NumberFormat class, which has static methods such as getCurrencyInstance and getNumberInstance that return object instances to format numbers in specific ways. One reason you might want to use this technique is to create classes that can have only one object instance. This type of class, called a singleton class , is described in the sidebar “The Singleton pattern ,” later in this chapter.
To provide utility functions that aren’t associated with an object at all: A good example in the Java API library is the Math class, which provides a bunch of static methods to do math calculations. Examples that you might code yourself are a DataValidation class with static methods that validate input data and a database class with static methods that perform database operations.

Working with Static Fields

A static field is a field that’s declared with the static keyword, like this:

private static int ballCount;

Note that the position of the static keyword is interchangeable with the positions of the visibility keywords ( private and public , as well as protected , which I describe in the next chapter). As a result, the following statement works as well:

static private int ballCount;

As a convention, most programmers tend to put the visibility keyword first.

Note that you can’t use the static keyword within a class method. Thus the following code won’t compile:

private void someMethod()
{
static int x;
}

In other words, fields can be static, but local variables can’t.

You can provide an initial value for a static field. Here’s an example:

private static String district = "Northwest";

Static fields are created and initialized when the class is first loaded. That happens when a static member of the class is referred to or when an instance of the class is created, whichever comes first.

Another way to initialize a static field is to use a static initializer, which I cover later in this chapter, in the section “Using Static Initializers .”

Using Static Methods

A static method is a method declared with the static keyword. Like static fields, static methods are associated with the class itself, not with any particular object created from the class. As a result, you don’t have to create an object from a class before you can use static methods defined by the class.

The best-known static method is main , which is called by the Java runtime to start an application. The main method must be static — which means that applications are run in a static context by default.

One of the basic rules of working with static methods is that you can’t access a nonstatic method or field from a static method, because the static method doesn’t have an instance of the class to use to reference instance methods or fields. The following code won’t compile:

public class TestClass
{
private int x = 5; // an instance field

public static void main(String[] args)
{
int y = x; // error: won't compile
}
}

Here the main method is static, so it can’t access the instance variable x .

Note: You can access static methods and fields from an instance method, however. The following code works fine:

public class Invoice
{
private static double taxRate = 0.75;

private double salesTotal;

public double getTax()
{
return salesTotal * taxRate;
}
}

Here the instance method named salesTotal has no trouble accessing the static field taxRate .

Counting Instances

One common use for static variables is to keep track of how many instances of a class have been created. To illustrate how you can do this, consider the program in Listing 3-1 . This program includes two classes. The CountTest class is a simple class that keeps track of how many times its constructor has been called. Then the CountTestApp class uses a for loop to create 10 instances of the class, displaying the number of instances that have been created after it creates each instance.

Note that the instance count in this application is reset to zero each time the application is run. As a result, it doesn’t keep track of how many instances of the CountTest class have ever been created — only of how many have been created during a particular execution of the program.

LISTING 3-1 The CountTest Application

public class CountTestApp →1
{
public static void main(String[] args)
{
printCount();
for (int i = 0; i < 10; i++)
{
CountTest c1 = new CountTest(); →8
printCount(); →9

}
}
private static void printCount()
{
System.out.println("There are now " →15
+ CountTest.getInstanceCount()
+ " instances of the CountTest class.");
}
}
class CountTest →21
{
private static int instanceCount = 0; →23

public CountTest() →25
{
instanceCount++;
}

public static int getInstanceCount() →29
{
return instanceCount;
}
}

The following paragraphs describe some of the highlights of this program:

→1 This line is the start of the CountTestApp class, which tests the CountTest class.
→8 This line creates an instance of the CountTest class. Because this code is contained in a for loop, 10 instances are created.
→9 This line calls the printCount method, which prints the number of CountTest objects that have been created so far.
→15 This line prints a message indicating how many CountTest objects have been created so far. It calls the static getInstanceCount method of the CountTest class to get the instance count.
→21 This line is the start of the CountTest class.
→23 The static instanceCount variable stores the instance count.
→25 This line is the constructor for the CountTest class. Notice that the instanceCount variable is incremented within the constructor. That way, each time a new instance of the class is created, the instance count is incremented.
→29 The static getInstanceCount method simply returns the value of the static instanceCount field.

THE SINGLETON PATTERN

A singleton is a class that you can use to create only one instance. When you try to create an instance, the class first checks to see whether an instance already exists. If so, the existing instance is used; if not, a new instance is created.

You can’t achieve this effect by using Java constructors, because a class instance has already been created by the time the constructor is executed. (That’s why you can use the this keyword from within a constructor.) As a result, the normal way to implement a singleton class is to declare all the constructors for the class as private. That way, the constructors aren’t available to other classes. Then you provide a static method that returns an instance. This method either creates a new instance or returns an existing instance.

Here’s a bare-bones example of a singleton class:

class SingletonClass
{
private static SingletonClass instance;

private SingletonClass()
{
}

public static SingletonClass getInstance()
{
if (instance == null)
instance = new SingletonClass();
return instance;
}
}

Here the SingletonClass contains a private instance variable that maintains a reference to an instance of the class. Then a default constructor is declared with private visibility to prevent the constructor from being used outside the class. Finally, the static getInstance method calls the constructor to create an instance if the instance variable is null. Then it returns the instance to the caller.

Here’s a bit of code that calls the getInstance method twice and then compares the resulting objects:

SingletonClass s1 = SingletonClass.getInstance();
SingletonClass s2 = SingletonClass.getInstance();
if (s1 == s2)
System.out.println("The objects are the same");
else
System.out.println("The objects are not the same");

When this code is run, the first call to getInstance creates a new instance of the SingletonClass class. The second call to getInstance simply returns a reference to the instance that was created in the first call. As a result, the comparison in the if statement is true, and the first message is printed to the console.

Preventing Instances

Sometimes you want to create a class that can’t be instantiated at all. Such a class consists entirely of static fields and methods. A good example in the Java API is the Math class. Its methods provide utility-type functions that aren’t really associated with a particular object. You may need to create similar classes yourself occasionally. You might create a class with static methods for validating input data, for example, or a database access class that has static methods to retrieve data from a database. You don’t need to create instances of either of these classes.

You can use a simple trick to prevent anyone from instantiating a class. To create a class instance, you have to have at least one public constructor. If you don’t provide a constructor in your class, Java automatically inserts a default constructor, which happens to be public.

All you have to do to prevent a class instance from being created, then, is provide a single private constructor, like this:

public class Validation
{
private Validation() {} // prevents instances

// static methods and fields go here
}

Now, because the constructor is private, the class can’t be instantiated.

Incidentally, the Math class uses this technique to prevent you from creating instances from it. Here’s an actual snippet of code from the Math class:

public final class Math {
/**
* Don't let anyone instantiate this class.
*/
private Math() {}

I figure that if this trick is good enough for the folks who wrote the Math class, it’s good enough for me.

Using Static Initializers

In the preceding chapter, you discover initializer blocks that you can use to initialize instance variables. Initializer blocks aren’t executed until an instance of a class is created, so you can’t count on them to initialize static fields. After all, you might access a static field before you create an instance of a class.

Java provides a feature called a static initializer that’s designed specifically to let you initialize static fields. The general form of a static initializer looks like this:

static
{
statements…
}

As you can see, a static initializer is similar to an initializer block but begins with the word static . As with an initializer block, you code static initializers in the class body but outside any other block, such as the body of a method or constructor.

The first time you access a static member such as a static field or a static method, any static initializers in the class are executed — provided that you haven’t already created an instance of the class. That’s because the static initializers are also executed the first time you create an instance. In that case, the static initializers are executed before the constructor is executed.

If a class has more than one static initializer, the initializers are executed in the order in which they appear in the program.

Here’s an example of a class that contains a static initializer:

class StaticInit
{
public static int x;

static
{
x = 32;
}

// other class members such as constructors and
// methods go here…
}