Java Tutorial

This Java tutorial is tailored for newcomers, offering a journey from basic principles to complex Java programming techniques. Completing this tutorial equips you with a solid understanding of Java, preparing you for advanced learning. You'll emerge ready to tackle the challenges of becoming a top-tier software engineer, with the skills to innovate and excel in the vast world of software development.

Singleton Class
Java Singleton Design Pattern
Singleton pattern is one of the simplest design patterns in Java. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.
Java Singleton Class
This pattern involves a single class which is responsible to create an object while making sure that only single object gets created. This class provides a way to access its only object which can be accessed directly without need to instantiate the object of the class.
Since there is only one Singleton instance, any instance fields of a Singleton will occur only once per class, just like static fields. Singletons often control access to resources, such as database connections or sockets.
For example, if you have a license for only one connection for your database or your JDBC driver has trouble with multithreading, the Singleton makes sure that only one connection is made or that only one thread can access the connection at a time.
Advantages of Singleton Design Pattern
Singleton design pattern saves memory because only one object instance is created and it also provides global access to its instance.
Use of Singleton Design Pattern
The singleton design pattern is used when you want to create such a class that has only one instance. It is mainly used in multithreading to create multi-threaded and database-related applications.
Some of the designs where singleton design pattern is used:
To create logger classes
To create configuration management-related classes
To create classes related to database connection pooling
To create a class for the caching mechanism
Java Singleton Class/Design Pattern: Examples
Example 1
The easiest implementation consists of a private constructor and a field to hold its result, and a static accessor method with a name like getInstance().
The private field can be assigned from within a static initializer block or, more simply, using an initializer. The getInstance() method (which must be public) then simply returns this instance 
package com.tutorialspoint;
﻿
class Singleton {
﻿
   private static Singleton singleton = new Singleton( );
﻿
   /* A private Constructor prevents any other
    * class from instantiating.
    */
   private Singleton() { }
﻿
   /* Static 'instance' method */
   public static Singleton getInstance( ) {
      return singleton;
   }
﻿
   /* Other methods protected by singleton-ness */
   protected void demoMethod( ) {
      System.out.println("demoMethod for singleton");
   }
}
public class Tester {
﻿
   public static void main(String[] args) {
      Singleton tmp = Singleton.getInstance( );
      tmp.demoMethod( );
   }
}
If you compile and execute the above program, you will get the following result 
Output
demoMethod for singleton
Example 2
Following implementation shows a classic Singleton design pattern. In this example, the ClassicSingleton class maintains a static reference to the lone singleton instance and returns that reference from the static getInstance() method.
﻿
Here, ClassicSingleton class employs a technique known as lazy instantiation to create the singleton; as a result, the singleton instance is not created until the getInstance() method is called for the first time. This technique ensures that singleton instances are created only when needed.
package com.tutorialspoint;
﻿
class ClassicSingleton {
﻿
   private static ClassicSingleton instance = null;
   private ClassicSingleton() {
      // Exists only to defeat instantiation.
   }
﻿
   public static ClassicSingleton getInstance() {
      if(instance == null) {
         instance = new ClassicSingleton();
      }
      return instance;
   }
   
   protected void demoMethod( ) {
      System.out.println("demoMethod for singleton");
   }
}
public class Tester {
﻿
   public static void main(String[] args) {
      ClassicSingleton tmp = ClassicSingleton.getInstance( );
      tmp.demoMethod( );
   }
}
If you compile and execute the above program, you will get the following result 
Output
demoMethod for singleton
Example 3
Following implementation shows a threadsafe Singleton object creation. In this example, the ClassicSingleton class maintains a static reference to the lone singleton instance and returns that reference from the static getInstance() method which we've made threadsafe using synchronized keyword.
﻿
class ClassicSingleton {
﻿
   private static ClassicSingleton instance = null;
   private ClassicSingleton() {
      // Exists only to defeat instantiation.
   }
﻿
   public static synchronized ClassicSingleton getInstance() {
      if(instance == null) {
         instance = new ClassicSingleton();
      }
      return instance;
   }
   
   protected void demoMethod( ) {
      System.out.println("demoMethod for singleton");
   }
}
public class Tester {
﻿
   public static void main(String[] args) {
      ClassicSingleton tmp = ClassicSingleton.getInstance( );
      tmp.demoMethod( );
   }
}
If you compile and execute the above program, you will get the following result 
Output
demoMethod for singleton
﻿
﻿
﻿
﻿

Java Tutorial

Java Control Statements

Object Oriented Programming

Java Built-in Classes

Java File Handling

Java Error & Exceptions

Java Multithreading

Java Synchronization

Java Networking

Java Collections

Java List Interface

Java Queue Interface

Java Map Interface

Java Set Interface

Java Data Structures

Java Collections Algorithms

Java Miscellaneous

Java Tutorial

Singleton Class

Java Singleton Design Pattern

Java Singleton Class

Advantages of Singleton Design Pattern

Use of Singleton Design Pattern

Java Singleton Class/Design Pattern: Examples

Example 1

Output

Example 2

Output

Example 3

Output