Core Java Concepts and Syntax

Understanding Singleton Class in Java

Board Infinity
Board Infinity
Understanding Singleton Class in Java

    Java Programs: Know the Best Java Programs for Beginners

    Interesting Java Project Ideas For Beginners

    OOPs Concepts In Java

    Abstraction Vs Encapsulation in Java

    Understanding Overloading in Java

    Understanding Singleton Class in Java

    Understanding Multiple Inheritance in Java

    Learn about Generics in Java

    A quick guide to Access Modifiers in Java

    Understanding Polymorphism in Java

    Understanding the LifeCycle of an Applet in Java

    What is Composition in Java?

    Understanding Servlets in Java

    Understanding Java Comparator Interface

    Learn about Map Stream in Java

    Understanding Wrapper Class in Java

    Learn about JVM in Java

    Understand HashSet in Java

    Learn how to do Pyramid Pattern printing in Java

    Learn about Thread Sleep Method in Java

    Learn about Throw and Throws in Java

    Introduction to StringBuffer in Java

    What is Immutable Class in Java?

    Introduction to Static Keyword in JAVA

    How to sort a list in Java?

    Print Fibonacci Series in JAVA

    Understanding Anonymous Inner Class in JAVA

    Learn to Create an Array of Objects in Java

    Types of Variables in Java

    Learn about Java List

    Classes and Objects in Java

    Abstraction in Java

    Constructor Overloading in Java

    Method Signature In Java

    Method Overloading And Overriding In Java


Introduction

The purpose of design patterns is to solve a specific problem.
A popular design pattern is the Singleton design pattern. This method solves various problems by creating only one object of one class and using it wherever needed.

What is a Singleton class in Java?

The Singleton Pattern recommends defining a class with only one instance and providing global access to it.

To put it another way, a class should only create a single instance, and only one object should get used by all other classes. In the Singleton class, the goal is to limit the number of objects, controlling their creation.

The singleton design pattern comes in two forms:

  • Early Instantiation: Creating instances at runtime.
  • Lazy Instantiation: Creating new instances as needed.

Singletons get instantiated once, and their variable points to their instance. Consequently, anything we modify inside a class is visible if it is accessed through any variable of a class type defined and affects all variables within the class type.

Java Singleton Class Syntax:

class Singleton_Example {

   // Private field referring to the object
   private static Singleton_Example single_object;
                                             
  private Singleton_Example () {
      // Singleton_Example class constructor
   }

   public static Singleton_Example getInstance() {
      // Write code that creates only one object
      // Access the object as needed
   }
}

Benefits of using Singleton Design pattern

  • The Singleton object prevents other objects from instantiating their own copies, allowing them to access the same instance.
  • Due to the class's control over the instantiation process, it is flexible in how it can change the instantiation.
  • As we know, when we create objects of any class, they occupy memory space, so creating many of them will consume more memory. Because singletons have only one object, they save memory.

How to create a Singleton class in Java?

Creating a singleton class requires creating a static member, a private constructor, and a static factory method.

  1. Static member: Because it is static, it only gets memory once, containing the singleton instance.
  2. Private constructor: This prevents outsiders from instantiating the Singleton class.
  3. Factory static method: The static factory method returns the instance of the Singleton object to its caller.

The following properties must get implemented to create a singleton class:

  • Create a private constructor of the class so that objects can only get created within the class.
  • Create a private attribute of the class type referencing the single object.
  • Create a public static method for creating and accessing the object. We will create a condition inside the method to prevent multiple object creation.

The following example shows how a singleton class works in Java.

class Database_conn {
   private static Database_conn dbObject;

   private Database_conn() {     
  }

   public static Database_conngetInstance() {

      // creating object if not already created
      if(dbObject == null) {
         dbObject = new Database_conn();
      }

       // returns the singleton object
       return dbObject;
   }

   public void getConnection() {
       System.out.println("Connection to the database established.");
   }
}

class Main {
   public static void main(String[] args) {
      Database_conndb1;

      // This refers to the only object in Database_conn
      db1= Database_conn.getInstance();
     
      db1.getConnection();
   }
}

write your code here: Coding Playground

Conclusion

The Singleton Pattern is a design pattern that restricts client access to a single of class. It is used to provide a global point of access to an object and avoid the use of multiple objects in this case.

It ensures that there is only one instance of an object in the system which makes it easier for the programmer to deal with it.