Join our newsletter for the latest updates.

Java Singleton

In this tutorial, we will learn about Java Singleton with the help of examples.

Java Singleton ensures that only one object of a class can be created.

Here's how we can implement singletons in Java.

  • create a private constructor that restricts to create an object outside of the class
  • create a private attribute that refers to the singleton object.
  • create a public static method that allows us to create and access the object we created. Inside the method, we will create a condition that restricts us from creating more than one object.

Java Singleton Example

class SingletonExample {

// private field that refers to the object
   private static SingletonExample singleObject;

   private SingletonExample() {
      // constructor of the SingletonExample class
   }

   public static SingletonExample getInstance() {
      // write code that allows us to create only one object
      // access the object as per our need
   }
}

In the above example,

  • private static SingletonExample singleObject - a reference to the object of the class.
  • private SingletonExample() - a private constructor that restricts creating objects outside of the class.
  • public static SingletonExample getInstance() - this method returns the reference to the only object of the class. Since the method static, it can be accessed using the class name.

Use of Singleton in Java

Singletons can be used while working with databases. They can be used to create a connection pool to access the database while reusing the same connection for all the clients. For example,

class Database {
   private static Database dbObject;

   private Database() {      
   }

   public static Database getInstance() {

      // create object if it's not already created
      if(dbObject == null) {
         dbObject = new Database();
      }

       // returns the singleton object
       return dbObject;
   }

   public void getConnection() {
       System.out.println("You are now connected to the database.");
   }
}

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

      // refers to the only object of Database
      db1= Database.getInstance();
      
      db1.getConnection();
   }
}

When we run the program, the output will be:

You are now connected to the database.

In our above example,

  • We have created a singleton class Database.
  • The dbObject is a class type field. This will refer to the object of the class Database.
  • The private constructor Database() prevents object creation outside of the class.
  • The static class type method getInstance() returns the instance of the class to the outside world.
  • In the Main class, we have class type variable db1. We are calling getInstance() using db1 to get the only object of the Database.
  • The method getConnection() can only be accessed using the object of the Database.
  • Since the Database can have only one object, all the clients can access the database through a single connection.

Singleton is a design pattern rather than a feature specific to Java. A design pattern is like our code library that includes various coding techniques shared by programmers around the world.


It's important to note that, there are only a few scenarios (like logging) where singletons make sense. We recommend you avoid using singletons completely if you are not sure whether to use them or not. Learn more: What is so bad about Singleton?