Java Static

In this tutorial, we'll explore the static keyword and we'll find out how we can apply the static keyword to variables, methods, blocks and nested classes.

In the Java programming language, the keyword static means that the particular member belongs to a type itself, rather than to an instance of that type.

This means we'll create only one instance of that static member that is shared across all instances of the class.


We can apply the keyword to variables, methods, blocks and nested classes.

static variable

In Java, when we declare a variable as static, then a single copy of that variable is created and shared among all instances of that class.

It doesn't matter how many times we initialize a class. There will always be only one copy of static variable belonging to it. The value of this static keyword variable will be shared across all objects of either the same or any different class.

Example:

Let's say we have a Car class with several attributes (instance variables). Whenever we initialize new objects from this Car blueprint, each new object will have its distinct copy of these instance variables.

That's where static variables come in:


  public class Car {
    private String name;
    private String engine;
    
    public static int numberOfCars;
    
    public Car(String name, String engine) {
        this.name = name;
        this.engine = engine;
        numberOfCars++;
    }

    // getters and setters
  }

Key Points to Remember

  1. 1). Since static variables belong to a class, we can access them directly using class name. So, we don't need any object reference.
  2. 2). We can only declare static variables at the class level.
  3. 3). We can access static variable without object initialization.
  4. 4). Finally, we can access static variable using an object reference (such as ford.numberOfCars++). But we should avoid this because it becomes difficult to figure out if it’s an instance variable or a class variable. Instead, we should always refer to static variables using class name (Car.numberOfCars++).

Static Method

Similar to static variable, static methods also belong to a class instead of the object. So, we can call them without creating the object of the class.

Example of static Method:

We generally use static methods to perform an operation that is not dependent upon instance creation. In order to share a code across all instances of that class, we write that code in a static method:


  public static void setNumberOfCars(int numberOfCars) {
    Car.numberOfCars = numberOfCars;
}

We also commonly use static methods to create utility or helper classes so that we can get them without creating a new object of these classes.

Just take a look at Collections or Math utility classes from JDK, StringUtils from Apache or CollectionUtils from Spring framework and notice that all methods are static.

Key Points to Remember

  1. 1). static methods in Java are resolved at compile time. Since method overriding is part of Runtime Polymorphism, static methods can't be overridden.
  2. 2). Abstract methods can't be static.
  3. 3). Static methods can't use this or super keywords.
  4. 4). Instance methods can also access static variables and static methods directly.
  5. 5). Static methods can access all static variables and other static methods.
  6. 6). Static methods can't access instance variables and instance methods directly. They need some object reference to do so.

Static block

We use a static block to initialize static variables. Although we can initialize static variables directly during declaration, there are situations when we need to do the multiline processing.

In such cases, static blocks come in handy. If static variables require additional, multi-statement logic during initialization, we can use a static block.

The static Block Example

Suppose we want to initialize a list object with some predefined values.

This becomes easy with static blocks:


  public class StaticBlockDemo {
    public static List<String> ranks = new LinkedList<>();

    static {
        ranks.add("Lieutenant");
        ranks.add("Captain");
        ranks.add("Major");
    }
    
    static {
        ranks.add("Colonel");
        ranks.add("General");
    }
  }

It wouldn't be possible to initialize a List object with all the initial values along with declaration. That's why we've utilized the static block here.

Key Points to Remember

  1. a). A class can have multiple static blocks.
  2. b). Static fields and static blocks are resolved and run in the same order as they are present in the class.

Static class

Java programming language allows us to create a class within a class. It provides a compelling way of grouping elements that we'll only use in one place. This helps to keep our code more organized and readable.

The nested class architecture is divided into two:

  1. 1). Nested classes that we declare static are called static nested classes.
  2. 2). Nested classes that are non-static are called inner classes.

The main difference between these two is that the inner classes have access to all members of the enclosing class (including private), whereas the static nested classes only have access to static members of the outer class.

In fact, static nested classes behave exactly like any other top-level class but are enclosed in the only class that will access it, to provide better packaging convenience.

Example of static Class

The most widely used approach to create singleton objects is through a static nested class:


  public class Singleton  {
    private Singleton() {}

    private static class SingletonHolder {
        public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

We use this method because it doesn't require any synchronization and is easy to learn and implement.

Key Points to Remember

  1. 1). Static nested classes do not have access to any instance members of the enclosing outer class. It can only access them through an object's reference.
  2. 2). Static nested classes can access all static members of the enclosing class, including private ones.
  3. 3). Java programming specification doesn't allow us to declare the top-level class as static. Only classes within the classes (nested classes) can be made as static.

Reasons to use

static variable

  1. a). When the value of the variable is independent of objects.
  2. b). When the value is supposed to be shared across all objects.
static methods
  1. a). To access/manipulate static variables and other static methods that don't depend upon objects.
  2. b). Static methods are widely used in utility and helper classes.
static block
  1. a). If the initialization of static variables needs some additional logic except the assignment.
  2. b). If the initialization of static variables is error-prone and needs exception handling.
static class
  1. a). Grouping classes that will be used only in one place increases encapsulation.
  2. b). We bring the code closer to the only place that will use it. This increases readability, and code is more maintainable.
  3. c). If a nested class doesn't require any access to its enclosing class instance members, it's better to declare it as static. This way, it won't be coupled to the outer class and is therefore more optimal, as they won't require any heap or stack memory.