Krutik Jayswal

Abstract factory design pattern is factory of factory design pattern. It is a creational design pattern in which we create multiple factory class and for creating factory object as well there will be main factory class. This is most complicated design pattern among other creational design patterns. Its better to understand factory pattern first as abstract factory is enhanced version of factory pattern. To simplify things, I will say we will be having one super factory class which will be responsible for creating factory object among several factory classes.

In abstract factory design pattern , we have multiple factory classes which are responsible for object creation. This factory classes are segregated based on the object categorization. Like in our case we have divided the object based on operating system of mobile device and then created factory classes for same. So there are two factory classes in our case Android Device Factory and Apple Device Factory, both of them are created from Abstract Factory class.so we will be using this abstract factory class only for creating objects.

Object which we will be creating is a Mobile Device , so the base interface will be MobileDevice using which the concret class will be created for actual mobile devices , In our case we have created devices like Android Device1,Apple Device 1 etc..

Let's cut the theory out and make some practical :)

MobileDevice.java

 package com.design.pattern.abstract_factory;

public interface MobileDevice {
	public void printDeviceType();
}
 

AndroidDevice1.java

 package com.design.pattern.abstract_factory;

public class AndroidDevice1 implements MobileDevice {

	@Override
	public void printDeviceType() {
		System.out.println("This is Android Device 1");
	}

}
 

AndroidDevice2.java

 package com.design.pattern.abstract_factory;

public class AndroidDevice2 implements MobileDevice {

	@Override
	public void printDeviceType() {
		System.out.println("This is Android Device 2");
	}

}
 

AppleDevice1.java

 package com.design.pattern.abstract_factory;

public class AppleDevice1 implements MobileDevice {

	@Override
	public void printDeviceType() {
		System.out.println("This is Apple Device 1");
	}

}
 

AppleDevice2.java

 package com.design.pattern.abstract_factory;

public class AppleDevice2 implements MobileDevice {

	@Override
	public void printDeviceType() {
		System.out.println("This is Apple Device 2");
	}

}
 

AbstractFactory.java

 package com.design.pattern.abstract_factory;

public abstract class AbstractFactory {
	abstract MobileDevice getMobileDevice(String deviceName) ;
}
 

AndroidDeviceFactory.java

 package com.design.pattern.abstract_factory;

public class AndroidDeviceFactory extends AbstractFactory {
	

	@Override
	MobileDevice getMobileDevice(String deviceName) {
		if(deviceName.equals("AndroidDevice1")) {
			return new AndroidDevice1();
		}else if(deviceName.equals("AndroidDevice2")) {
			return new AndroidDevice2();
		}else {
			return null;
		}
	}

}
 

AppleDeviceFactory.java

 package com.design.pattern.abstract_factory;

public class AppleDeviceFactory  extends AbstractFactory {

	@Override
	MobileDevice getMobileDevice(String deviceName) {
		if(deviceName.equals("AppleDevice1")) {
			return new AppleDevice1();
		}else if(deviceName.equals("AppleDevice2")) {
			return new AppleDevice2();
		}else {
			return null;
		}
	}

}
 

DeviceFactoryProducer.java

 package com.design.pattern.abstract_factory;

public class DeviceFactoryProducer {
	public static AbstractFactory getDeviceFactory(boolean needOpenSourceOS) {
		if (needOpenSourceOS) {
			return new AndroidDeviceFactory();
		} else {
			return new AppleDeviceFactory();
		}
	}
}
 

AbstractFactoryDemo.java

 package com.design.pattern.abstract_factory;

public class AbstractFactoryDemo {
	public static void main(String[] args) {
		AbstractFactory openSourceDeviceFactory=DeviceFactoryProducer.getDeviceFactory(true);
		
		MobileDevice android1=openSourceDeviceFactory.getMobileDevice("AndroidDevice1");
		android1.printDeviceType();
		
		MobileDevice android2=openSourceDeviceFactory.getMobileDevice("AndroidDevice1");
		android2.printDeviceType();
		
		AbstractFactory closedSourceDeviceFactory=DeviceFactoryProducer.getDeviceFactory(false);
		
		MobileDevice apple1=closedSourceDeviceFactory.getMobileDevice("AppleDevice1");
		apple1.printDeviceType();

		MobileDevice apple2=closedSourceDeviceFactory.getMobileDevice("AppleDevice2");
		apple2.printDeviceType();
	}
}
 

Factory design pattern is creational design pattern , this design pattern is used whenever developer does not need to expose the object creational logic. In factory pattern objects are created using the factory class. This class will be having the object creation part. So when ever the new object is needed of specific type we can create the object using the factory class. Below diagram shows the basic structure of factory pattern.

One of the example where we can use this design pattern is in a case some predefined parameters are there for creating object. So what we can do in our case is , we can pass the type of object in getShape() method and based on the type with default attributes we can return the required object.

Let's see some practical example of it.

Shape Class

package com.design.pattern.factory;

public interface Shape {
	void draw();
}

Circle Class

package com.design.pattern.factory;

public class Circle implements Shape {

	@Override
	public void draw() {
		System.out.println("Drawing circle...");
	}

}

  

Triangle Class

package com.design.pattern.factory;

public class Triangle implements Shape {

	@Override
	public void draw() {
		System.out.println("Drawing triangle...");
	}

}
  

Rectangle Class

package com.design.pattern.factory;

public class Rectangle  implements Shape {

	@Override
	public void draw() {
		System.out.println("Drawing rectangle...");
	}

}

ShapeFactory Class

package com.design.pattern.factory;

public class ShapeFactory {

	public static final String CIRCLE="circle";
	public static final String TRIANGLE="triangle";
	public static final String RECTANGLE="rectangle";
	
	public Shape getShape(String shapeType) {
		if (shapeType == null) {
			return null;
		}
		if (shapeType.equalsIgnoreCase(CIRCLE)) {
			return new Circle();

		} else if (shapeType.equalsIgnoreCase(RECTANGLE)) {
			return new Rectangle();

		} else if (shapeType.equalsIgnoreCase(TRIANGLE)) {
			return new Triangle();
		}

		return null;
	}

}

FactoryDemo Class

package com.design.pattern.factory;

public class FactoryDemo {

	public static void main(String[] args) {

		ShapeFactory shapeFactory = new ShapeFactory();

		Shape shape1 = shapeFactory.getShape(ShapeFactory.CIRCLE);
		Shape shape2 = shapeFactory.getShape(ShapeFactory.TRIANGLE);
		Shape shape3 = shapeFactory.getShape(ShapeFactory.RECTANGLE);
		shape1.draw();
		shape2.draw();
		shape3.draw();

	}
}

Prototype design pattern is creational design pattern. Developers needs to use this design pattern when the object creation is costlier in terms o resources or by some other means. One of the example of costly object creation is that , while creating object we need to make some database calls or may be some webservice calls. In this case we should use prototype design pattern. This pattern is doing nothing special , what it does is it is cashing the new created object and whenever required it will clone this cashed object and will return that copy to the client.

We will be having one abstract class in which we will be implementing the cloneable interface. The reason behind implementing the cloneable interface is that, that every subsequent class which will be extending this base abstract class will be using this base method implementation from abstract class. In above mentioned class we have the abstract class named as Shape so we will implement clone method in that class.

One more things which needs to be done is, we need to create each type of object and cache it in some kind of store like HashMap or HashTable and whenever required we can return the required type of object by cloning the cached copy. Let's see some practical example now.

Abstract Shape Class

public abstract class Shape implements Cloneable {

	public  Object clone() {
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return clone;
	}

	abstract String displayType();

}

Circle Class

package com.design.pattern.prototype;

public class Circle extends Shape {

	private String type;

	public Circle() {
		this.type = "Circle";
	}
	
	public String displayType() {
		return "This is "+type+" of object";
	}
}

Rectangle Class

package com.design.pattern.prototype;

public class Rectangle extends Shape {
	private String type;

 	public Rectangle() {
		this.type = "rectangle";
	}
	
	public String displayType() {
		return "This is "+type+" of object";
	}
}

Triangle Class

package com.design.pattern.prototype;

public class Triangle extends Shape{
	 	private String type;
	 	
	 	public Triangle() {
			this.type = "Triangle";
		}
	 	
		public String displayType() {
			return "This is "+type+" of object";
		}
}

ShapeStore Class

package com.design.pattern.prototype;

import java.util.HashMap;
import java.util.Map;

public class ShapeStore {
	
	public static Map cachedObjects=new HashMap<>();
	
	public static void loadObjects() {
		cachedObjects.put("circle", new Circle());
		cachedObjects.put("triangle", new Triangle());
		cachedObjects.put("rectangle", new Rectangle());
	}
	
	public static Shape getShape(String shape) {
		return (Shape) cachedObjects.get(shape).clone();
	}
	
}

PrototypeDemo Class

package com.design.pattern.prototype;

public class PrototypeDemo {

	public static void main(String[] args) {

		ShapeStore.loadObjects();
		Shape circle=ShapeStore.getShape("circle");
		Shape triangle=ShapeStore.getShape("triangle");
		Shape rectangle=ShapeStore.getShape("rectangle");
		
		System.out.println(circle.displayType());
		System.out.println(triangle.displayType());
		System.out.println(rectangle.displayType());
	}
}

The name is singleton design pattern it self tells us regarding what exactly this design pattern will do. Using singleton design pattern we can restrict the object or instance creation only to one instance. So using singleton design pattern only one instance/object of a class will get created.

Theoretical we will maintain only one instance of a class inside class. A simple singleton class will have variables, methods and constructor as per below diagram.

A simple singleton class will have a instance variable which will maintain the single instance of a class, the reason behind private constructor is that it will not allow object creation outside the class and finally the public get instance method to fetch the instance. Now let's see the java example for same.

 
public class SingleTon {
	
	private static SingleTon instance= new SingleTon();
	
	//private allowed object creation only inside the class
	private SingleTon() {

	}
	
	public static SingleTon getInstance() {
		return instance;
	}
	
}