Java Static Instance of Class

The fundamental units of object-oriented programming in Java are classes. They enable us to specify the composition and operation of objects. The static instance of a class is a key idea in Java. One instance of a class that is shared by all objects of that class is represented by a static instance. We shall examine the function and application of Java static instances in this post.

The distinction between static and non-static class members should be understood first. Variables and methods are examples of non-static members that are specific to each individual object made from the class. Non-static members are duplicated in each object, and the only way to access these members is through an instance of the class.

Static members, however, are members of the class itself and not of any particular object. All objects in the class can access them. Instead of an instance of an object, static members are accessible using the class name. Static members are defined in Java using the'static' keyword.

The idea of a static instance of a class will now be discussed. One instance of a class that is shared by all objects is referred to as a static instance. When we want to preserve a shared state or behaviour across several instances of a class, we usually utilise it.

To create a static instance, we declare a static member variable in the class and initialize it with an instance of the class itself. For example:

MyClass.java

public class MyClass {
    private static MyClass instance = new MyClass();
    private MyClass() {
        // Private constructor to prevent external instantiation
    }
    public static MyClass getInstance() {
        return instance;
    }
    // Other non-static members and methods...
}

The static instance of the class is stored in a private static member variable called instance in the code above. To prevent the class from being instantiated externally, the constructor is also made private. Instead, we offer the static instance via the static function getInstance().

We make sure that every object in the class has the same state and behaviour by utilising a static instance. It can be especially helpful in situations like managing global setups, keeping a cache, or putting singleton concepts into practise.

The Singleton design pattern is an example of a frequent use case for a static instance. The Singleton pattern limits the number of objects that can be created from an instance of a class. We ensure that just one instance of the class can exist by utilising a static instance and a private constructor. This is helpful when we want to make sure a class, such a database connection or a logger, only has one instance throughout the entire application.

To access the static instance, we simply call the getInstance() method on the class itself. For example:

MyClass obj1 = MyClass.getInstance();
MyClass obj2 = MyClass.getInstance();

The same static instance of MyClass will be referred to by obj1 and obj2 in the code above. The other object will also reflect any modifications made to the instance made through the first object.

The static instance is shared by the entire programme, which is an important point to remember. Due to the possibility of many threads accessing it at once, we must guarantee that it is thread-safe. Lazy initialization strategies or synchronisation mechanisms can be used to accomplish this.

Here's a complete code example demonstrating the concept of a Java static instance of a class:

File Name: MyClass.java

public class MyClass {
    private static MyClass instance = new MyClass();
    private int count;
    private MyClass() {
        // Private constructor to prevent external instantiation
        count = 0;
    }
    public static MyClass getInstance() {
        return instance;
    }
    public void incrementCount() {
        count++;
    }
    public int getCount() {
        return count;
    }
    public static void main(String[] args) {
        MyClass obj1 = MyClass.getInstance();
        obj1.incrementCount();
        MyClass obj2 = MyClass.getInstance();
        obj2.incrementCount();
        System.out.println("Count from obj1: " + obj1.getCount()); // Output: Count from obj1: 2
        System.out.println("Count from obj2: " + obj2.getCount()); // Output: Count from obj2: 2
    }
}

Output:

Count from obj1: 2
Count from obj2: 2

The static instance of the class is represented in this example by a MyClass with a private static member variable instance. To avoid external instantiation, the constructor is private, and we offer the static function getInstance() to get the static instance.

The MyClass additionally includes two methods: incrementCount(), which increases the count, and getCount(), which retrieves the count, as well as an instance variable called count.

The static instance obj1 is obtained in the main() method, and its incrementCount() method is used to raise the count to 1. Then, after acquiring a second instance, obj2, we use its incrementCount() function once more, raising the count to 2.

Finally, we print the counts from both obj1 and obj2 using their getCount() methods, verifying that they both have the same count of 2.

This demonstrates that both obj1 and obj2 refer to the same static instance of MyClass, and any changes made to the instance are reflected across both objects.

In conclusion, a class' static instance in Java denotes a single instance that is shared by all of the class' objects. It is helpful for preserving a typical condition or action over numerous instances. We may manage the instantiation and access to the static instance by using a private constructor and a static member variable. Understanding and utilising static instances can significantly improve the flexibility and functionality of your Java programmes, whether it's for maintaining global configurations, creating singleton patterns, or other use cases.

Next TopicJava TreeMap Sort by Value

← prev next →