A Singleton Pattern ensures a class has only one object or instance and provides a global point of access to it.

A singleton is a class that can be instantiated only one time in a JVM per class loader. Repeated calls always return the same instance. Ensures that a class has only one instance, and provide a global point of access. It can be an issue if singleton class gets loaded by multiple class loaders.

/*
*
*  lazy creation of the object
*  ensure only one object
*
*  Chance of creating multiple
*  objects in multi threads environment.
*
*/

public class Singleton
{

	private static Singleton singleton;

	private Singleton(){
		System.out.println( "Create an object " +
		"which is having the private Constructor" );
	}

	public static Singleton getInstance(){
		if(singleton == null){
			singleton = new Singleton();
		}
		return singleton;
	}

}

/*
*
*  lazy creation of the object
*  ensure only one object in conditions
*  of multiple threading environment
*
*  Every time you call a method
*  it is locks up to give you the object
*  synchronized block is expensive
*
*/
class SingletonSync
{

	private static SingletonSync singleton;

	private SingletonSync(){
		System.out.println( "Create an object " +
				"which is having the private" );
	}

	public static synchronized SingletonSync getInstance(){
		if(singleton == null){
			singleton = new SingletonSync();
		}
		return singleton;
	}

}

/**
 *  This method of creation of the object is defining and initializing the object
 *
 *  ensure only one object in conditions of multiple threading environment without
 *  using the synchronized block
 *
 *  you will find an object weather it is used or not
 *  So it will occupy memory etc.
 *
 */
class SingletonEager {

	private static SingletonEager
		single = new SingletonEager();

	private SingletonEager(){
		System.out.println( "Create an object " +
				"which is having the private" );
	}

	public static SingletonEager getInstance(){
		return single;
	}

}
/**
 * I think this is the most preferable
 *  way of implementing the singleton pattern
 *
 *  lazy creation of the object
 *  ensure only one object in conditions
 *  of multiple threading environment
 *  only one time synchronization block is used.
 *
 *  synchronized block is expensive
 *
 */

class SingletonDoubleCheck {

	// The volatile keyword ensures that multiple threads
	// handle the unique instance variable correctly
	// when it is being initialized to the singleton instance
	private volatile static SingletonDoubleCheck singleton;

	private SingletonDoubleCheck(){
		System.out.println( "Create an object" +
				" with double checked syncronized" );
	}

    // we only synchronize one time when it cont found the object
	public static SingletonDoubleCheck getInstance(){
		if(singleton == null){
			synchronized (SingletonDoubleCheck.class) {
				singleton = new SingletonDoubleCheck();
			}
		}
		return singleton;
	}
}

The builder pattern encapsulate or separate the construction of a complex object from its representation so that the same construction process can create different representations.

The Builder Pattern

What is the strategy of creating objects. weather we use “new” key word to create an object or we are using the method to get the created object.

Factory pattern defines a way and handle creation the objects. It is basically talks about the obtects which are helpful to create the object without knowing the class of the object.Factory pattern encapsulate object creation.

How do we implement Factory pattern?

Accroding to GOF

Define an interface for creating an object but let subclasses decide which class to instanciate. Factory method lets a class difer instantiation to subclass.

So we have popular patterns such as Singleton, Factory, Abstract Factory, Builder, Prototype etc. we will see these and discuss in details in next posts

The abstract class implement the interface and the concrete classes extends the behaviour of the abstract class.

Don’t  chose only between interface and abstract class. Let abstract class implement the interface and the concrete classes extend the abstract class.

Interfaces can be used to hide the specific class that implement the behavior from the client classes

Organize the classes that provide related behavior common the the abstract super class helps to ensure consistency of implementation

Using both interface and abstract class pattern helps the object desing to get the benefit of both the interface and abstract classes.

We are focused most on the technological design and design pattern applied for architecting the software application. Irrespective of technology we discuss here most importantly the intent, advantages and disadvantages of the design patterns.  Please join hands with us to contribute to this cause to make this blog helpful for those who really wants to understand the design pattern and apply in there daily life.