Sie sind auf Seite 1von 24
Design patterns - Creational By Srinivas Short description of Design Patterns - Creational Patterns ●

Design patterns - Creational

By Srinivas

Short description of Design Patterns - Creational Patterns

Introduction to Design Patterns.

Also covers, who implemented them first.

Uses of Design Patterns.

Types of Design Patterns.

Covers the Creational Design Patterns.

@2016

Attune

World

Wide

All

right

reserved.

Contents

Preface About This Guide Intended Audience Revision History

Design patterns - Introduction What is Gang of Four (GOF)?

Usage of Design Patterns Best Practices Common platform for developers

Types of Design Patterns Creational Patterns Structural Patterns Behavioral Patterns

Creational Design Patterns Design Pattern - Singleton Pattern Implementation Steps Design Patterns - Builder Pattern Implementation Steps Design Patterns - Prototype Pattern Implementation Steps

Conclusion

Design Patterns

Last Updated: November 2016

Patterns - Prototype Pattern Implementation Steps Conclusion Design Patterns Last Updated: November 2016 | Page 2

|

Page 2 of 24

Preface

Preface About This Guide This guide will help the the developer or individual, who wants to

About This Guide

This guide will help the the developer or individual, who wants to get the brief overview of Design patterns - Creational Patterns. We are going to see brief introduction about them, and we will discuss about them theoretically and programmatically about them.

Intended Audience

This guide is particularly intended for the developers who want to gain knowledge and insight into Design Patterns - Creational Patterns. The developers or audience must be having knowledge of the Core Java.

Revision History

This document is the first version of document which is going to cover regarding the topics of Design Patterns - Creational Patterns.

Design Patterns

Last Updated: November 2016

|

Page 3 of 24

Design patterns - Introduction Design patterns signifies the most best practices which have been used

Design patterns - Introduction

Design patterns signifies the most best practices which have been used by object- oriented software developers. Design patterns are a great solution for the problems that developers may face when they are developing the software.

These solutions have been obtained by trial and error by various software developers for quite a substantial period of time.In software engineering, we can say that a design pattern can be said as a general repeatable solution for any normally occurring problem

in terms of software design.

A design pattern cannot be said as a finished design which can be transformed directly

into some code. This can be said as a description or template for how solving any problem which can be used in various scenarios.

What is Gang of Four (GOF)?

In 1994, four authors Richard Helm, Erich Gamma, John Vlissides, and Ralph Johnson

published a book titled Design Patterns - Elements of Reusable Object-Oriented

Software which has initiated Design Patterns in Software development.

These authors have been called as Gang of Four (GOF) from then. According to these

authors, design patterns have been primarily based on the below principles of object

orientated design.

We have to Program to an interface and not for an implementation.

We have to favor object composition instead of inheritance.

Design Patterns

Last Updated: November 2016

|

Page 4 of 24

Usage of Design Patterns

Usage of Design Patterns Design Patterns have two main usages in software development. We can speed

Design Patterns have two main usages in software development. We can speed up the Design patterns and can speed up the development process by providing proven, tested development paradigms. Efficient software design may require so much consideration of the issues which are not visible, until later in the implementation.

Reusing design patterns may help in preventing subtle issues which can be causing major problems and may improve code readability for architects and coders who are familiar with patterns.

Normally, people can only understand how to apply some software design techniques for some type of problems. These techniques are often very difficult when we are applying them to some broad range of problems.

Design patterns can provide us some general solutions, which have been documented in a format that doesn’t require any specifics which are tied to particular problem.

Besides that, patterns can allow developers in communicating with well-known, and names for software interactions. The design patterns which are common can be improved over time, which makes them robust than the ad-hoc designs.

Best Practices

Design patterns have been evolving over a long time and they can provide us best solutions for certain problems which have been faced during development of software. If developers can learn these patterns, it can help them for learning software design in an faster and easy way.

Design Patterns

Last Updated: November 2016

|

Page 5 of 24

Common platform for developers Design patterns can provide us with standard terminology and can be

Common platform for developers

Design patterns can provide us with standard terminology and can be specific to some particular scenario. For example, a singleton design pattern can signify the use of single object, so all the developers who are familiar with single design pattern can make use of single object and can convey each other that program is following some singleton pattern.

Types of Design Patterns

As per reference book Design Patterns - Elements of Reusable Object-Oriented Software , in total we are having 23 design patterns which can be classified in three categories:

Structural, Creational and Behavioral patterns.

Creational Patterns

With these design patterns, we can get a way for creating objects while we are hiding creation logic, and we are rather instantiating objects directly by the usage of new operator. With this, we give program so much flexibility, in deciding which objects have to be created for any given use case.

Structural Patterns

These design patterns are concerned with object and class composition. Concept of inheritance have been used for composing interfaces and defining ways for composing objects and obtain new functionalities.

Behavioral Patterns

With these design patterns, we are concerned with communication between the objects.

Design Patterns

Last Updated: November 2016

|

Page 6 of 24

Creational Design Patterns In this document, we are going to see and know about Creational

Creational Design Patterns

In this document, we are going to see and know about Creational Design Patterns. We will discuss about them in a theoretical and programmatic manner.

Design Pattern - Singleton Pattern

Singleton pattern can be said as one of the simplest design patterns in Java. This singleton design pattern can be said as a design pattern, which comes under creational pattern as this pattern is providing us with one of best ways for creating an object.

This pattern gives us with a single class, which is responsible for creating an object while making sure, that only single object is getting created. This class gives us a way for accessing its only object, and this can be accessed directly without any need for instantiating the object of class.

Implementation Steps

Here, We're going to create some SingleObject class. SingleObject class can have a static instance of itself and its constructor have been set as private.

With SingleObject class, we get a static method for getting its static instance to outside world. Our demo class SingletonPatternDemo, will use the SingleObject class for getting a SingleObject object.

Design Patterns

Last Updated: November 2016

|

Page 7 of 24

Step 1 We should Create a Singleton Class. public class SingleObjectClass { //we should create
Step 1 We should Create a Singleton Class. public class SingleObjectClass { //we should create

Step 1

We should Create a Singleton Class.

public class SingleObjectClass {

//we should create a object of SingleObject private static SingleObjectClass instance = new SingleObjectClass();

// constructor is made private so that this class cannot be //instantiated private SingleObjectClass(){}

//Get the only object available public static SingleObjectClass getInstance(){ return instance;

}

public void showMessage(){ System.out.println("Hello World!");

}

}

Design Patterns

Last Updated: November 2016

|

Page 8 of 24

Step 2 Get the only object from the singleton class. SingletonPatternDemo.java

object from the singleton class. SingletonPatternDemo.java public class SingletonPatternDemo { public static void

public class SingletonPatternDemo {

public static void main(String[] args) {

//this is a illegal construct

//We will get Compile Time Error: The constructor SingleObject() is not visible

//SingleObjectClass object = new SingleObjectClass();

//Get the only object available

SingleObjectClass object = SingleObjectClass.getInstance();

//show the message object.showMessage();

}

}

Step 3

The output.

Hello World!

Design Patterns

Last Updated: November 2016

|

Page 9 of 24

Design Patterns - Builder Pattern

Design Patterns - Builder Pattern With Builder pattern, we can build a complex object with the

With Builder pattern, we can build a complex object with the usage of simple objects and we can follow a step by step approach for achieving this. This builder pattern comes

under creational pattern, as this pattern is providing with one of best ways for creating

an object.

A Builder class can build the final object on step by step basis. This builder is

independent of any other objects.

Implementation Steps

For this, We have to consider a business case of fast-food restaurant, where any typical meal could be a cold drink and burger. Burger could be a Chicken Burger or Veg Burger and it will be packed in some wrapper. Pepsi or coke could be a Cold drink and it will be packed in a bottle.

Now, We will create an Item interface, which is going to represent food items such as cold drinks and burgers, and concrete classes which implement the Item interface and a Packing interface which represents the food items packaging and concrete classes implementing the Packing interface as burger and they would be packed in wrapper and cold drink which would be packed as bottle.

We then create a Meal class which has a ArrayList of Item and a MealBuilder which builds different types of Meal objects which happens by combining Item. BuilderPatternDemo, our demo class uses MealBuilder for building a Meal.

Design Patterns

Last Updated: November 2016

|

Page 10 of 24

Design Patterns Last Updated: November 2016 | Page 11 of 24
Design Patterns Last Updated: November 2016 | Page 11 of 24

Design Patterns

Last Updated: November 2016

|

Page 11 of 24

Step 1 Let us create an interface Item, and this is representing packing and food

Step 1 Let us create an interface Item, and this is representing packing and food item.

Item.java

public interface Item { public Packing packing(); public String name(); public float price();

}

Packing.java

public interface Packing { public String pack();

}

Step 2 Now, Create concrete classes and they are implementing Packing interface. Wrapper.java

public class Wrapper implements Packing { @Override public String pack() { return "Wrapper";

}

}

Bottle.java

public class Bottle implements Packing {

@Override public String pack() { return "Bottle";

}

}

Step 3 After that, Create abstract classes that are implementing item interface, and they are providing you with default functionalities.

Design Patterns

Last Updated: November 2016

|

Page 12 of 24

Burger.java

Burger.java public abstract class Burger implements Item { @Override public abstract float price(); @Override public

public abstract class Burger implements Item {

@Override public abstract float price();

@Override public Packing packing() { return new Wrapper();

}

}

ColdDrink.java

public abstract class ColdDrink implements Item { @Override public abstract float price(); @Override public Packing packing() { return new Bottle();

}

}

Step 4 After them, Create concrete classes extending the ColdDrink and Burger classes VegBurger.java

public class VegBurger extends Burger { @Override public String name() { return "Veg Burger";

}

@Override public float price() { return 25.0f;

}

}

ChickenBurger.java

Design Patterns

Last Updated: November 2016

|

Page 13 of 24

public class ChickenBurger extends Burger { @Override public String name() { return "Chicken Burger"; }

public class ChickenBurger extends Burger {

@Override public String name() { return "Chicken Burger";

}

@Override public float price() { return 50.5f;

}

}

Coke.java

public class Coke extends ColdDrink { @Override public String name() { return "Coke";

}

@Override public float price() { return 30.0f;

}

}

Pepsi.java

public class Pepsi extends ColdDrink { @Override public String name() { return "Pepsi";

}

@Override public float price() { return 35.0f;

}

}

Step 5 Create a Meal class having Item objects defined above. Meal.java

Design Patterns

Last Updated: November 2016

|

Page 14 of 24

import java.util.ArrayList; import java.util.List; public class Meal {   private List<Item> items = new

import java.util.ArrayList; import java.util.List; public class Meal {

 

private List<Item> items = new ArrayList<Item>();

public float getCost(){ float cost = 0.0f;

for (Item item : items) { cost += item.price();

}

return cost;

}

public void showItems(){

for (Item item : items) { System.out.print("Item : " + item.name()); System.out.print(", Packing : " + item.packing().pack()); System.out.println(", Price : " + item.price());

}

}

public void addItem(Item item){ items.add(item);

}

}

 

Step 6

In step 6, Create a MealBuilder class, the actual builder class is now responsible for

creating the Meal objects.

MealBuilder.java

public class MealBuilder {

public Meal prepareNonVegMeal (){

Design Patterns

Last Updated: November 2016

|

Page 15 of 24

Meal meal = new Meal(); meal.addItem(new ChickenBurger()); meal.addItem(new Pepsi()); return meal; } public Meal

Meal meal = new Meal(); meal.addItem(new ChickenBurger()); meal.addItem(new Pepsi()); return meal;

}

public Meal prepareVegMeal (){ Meal meal = new Meal(); meal.addItem(new VegBurger());

meal.addItem(new Coke()); return meal;

}

}

Step 7

BuiderPatternDemo uses MealBuider to demonstrate builder pattern.

BuilderPatternDemo.java

public class BuilderPatternDemo { public static void main(String[] args) {

MealBuilder mealBuilder = new MealBuilder();

Meal nonVegMeal = mealBuilder.prepareNonVegMeal();

System.out.println("\n\nNon-Veg nonVegMeal.showItems(); System.out.println("Total Cost: " + nonVegMeal.getCost());

Meal");

Meal vegMeal = mealBuilder.prepareVegMeal(); System.out.println("Veg Meal"); vegMeal.showItems(); System.out.println("Total Cost: " + vegMeal.getCost());

}

}

Design Patterns

Last Updated: November 2016

|

Page 16 of 24

Step 8 Verify the output.

Step 8 Verify the output. Non-Veg   Meal Item : Chicken Burger, Packing : Wrapper, Price

Non-Veg

 

Meal

Item

:

Chicken

Burger,

Packing

:

Wrapper,

Price

:

50.5

Item

:

Pepsi,

Packing

:

Bottle,

Price

:

35.0

Total Cost: 85.5

Veg Meal Item : Veg Burger, Packing : Wrapper, Price : 25.0 Item : Coke, Packing : Bottle, Price : 30.0 Total Cost: 55.0

Design Patterns

Last Updated: November 2016

|

Page 17 of 24

Design Patterns - Prototype Pattern

Design Patterns - Prototype Pattern With Prototype pattern, we are going to create a duplicate object

With Prototype pattern, we are going to create a duplicate object and also keep the performance in mind. This Prototype Pattern normally comes under creational pattern, and this pattern gives us with one of relevant ways for creating any object.

This pattern involves implementing a prototype interface which specifies to create a clone of current object. This pattern can be used, when we want to create a object and while creation of object may cost resources for us.

For example, suppose an object should to be created, that to, after some costly database operation. For that to happen, we can cache the object, and we can return its clone on any next update and can also request the database as and whenever it is needed thus reducing the database calls.

Implementation Steps

We're going to create an abstract class Shape and concrete classes extending the Shape class. A class ShapeCache is defined as a next step which stores shape objects in a Hashtable and returns their clone when requested.

PrototypPatternDemo, our demo class will use ShapeCache class to get a Shape object.

Design Patterns

Last Updated: November 2016

|

Page 18 of 24

Step 1 Create an abstract class implementing Clonable interface. Shape.java public abstract class Shape implements
Step 1 Create an abstract class implementing Clonable interface. Shape.java public abstract class Shape implements

Step 1

Create an abstract class implementing Clonable interface.

Shape.java

public abstract class Shape implements Cloneable {

private String id; protected String type;

abstract void draw();

public String getType(){ return type;

}

public String getId() { return id;

}

Design Patterns

Last Updated: November 2016

|

Page 19 of 24

  public void setId(String id) { this.id = id; } public Object clone() { Object
 

public void setId(String id) { this.id = id;

}

public Object clone() { Object clone = null;

try { clone = super.clone();

} catch (CloneNotSupportedException e) { e.printStackTrace();

}

return clone;

}

}

 

Step 2

Create concrete classes extending the above class.

Rectangle.java

public class Rectangle extends Shape {

public Rectangle(){ type = "Rectangle";

}

@Override public void draw() { System.out.println("Inside Rectangle::draw() method.");

}

}

Design Patterns

Last Updated: November 2016

|

Page 20 of 24

Square.java

Square.java public class Square extends Shape { public Square(){ type = "Square"; } @Override public

public class Square extends Shape {

public Square(){ type = "Square";

}

@Override public void draw() { System.out.println("Inside Square::draw() method.");

}

}

Circle.java

public class Circle extends Shape {

public Circle(){ type = "Circle";

}

@Override public void draw() { System.out.println("Inside Circle::draw() method.");

}

}

Step 3

Create a class to get concrete classes from database and store them in a Hashtable.

ShapeCache.java

import java.util.Hashtable;

public class ShapeCache {

private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

public static Shape getShape(String shapeId) {

Design Patterns

Last Updated: November 2016

|

Page 21 of 24

  Shape cachedShape = shapeMap.get(shapeId); return (Shape) cachedShape.clone(); } // for each shape run
 

Shape cachedShape = shapeMap.get(shapeId); return (Shape) cachedShape.clone();

}

// for each shape run database query and create shape // shapeMap.put(shapeKey, shape); // for example, we are adding three shapes

public static void loadCache() { Circle circle = new Circle();

circle.setId("1");

shapeMap.put(circle.getId(),circle);

Square square = new Square();

square.setId("2");

shapeMap.put(square.getId(),square);

Rectangle rectangle = new Rectangle();

rectangle.setId("3");

shapeMap.put(rectangle.getId(), rectangle);

}

}

 

Step 4

PrototypePatternDemo uses ShapeCache class to get clones of shapes stored in a

Hashtable.

PrototypePatternDemo.java

public class PrototypePatternDemo { public static void main(String[] args) { ShapeCache.loadCache();

Shape clonedShape = (Shape) ShapeCache.getShape("1"); System.out.println("Shape : " + clonedShape.getType());

Shape clonedShape2 = (Shape) ShapeCache.getShape("2"); System.out.println("Shape : " + clonedShape2.getType());

Shape clonedShape3 = (Shape) ShapeCache.getShape("3"); System.out.println("Shape : " + clonedShape3.getType()); }}

Design Patterns

Last Updated: November 2016

|

Page 22 of 24

Step 5

Verify the output.

Step 5 Verify the output. Shape : Circle Shape : Square Shape : Rectangle Design Patterns

Shape : Circle Shape : Square Shape : Rectangle

Design Patterns

Last Updated: November 2016

|

Page 23 of 24

Conclusion Throughout this guide, we have come across and also covered various concepts which are

Conclusion

Throughout this guide, we have come across and also covered various concepts which are related to Design Patterns - Creational Patterns. Here, we also have covered about

the theoretical and programmatic part of creational patterns.

Design Patterns

Last Updated: November 2016

|

Page 24 of 24