i
About the Tutorial
Design patterns represent the best practices used by experienced object-oriented software developers. Design patterns are solutions to general problems that software developers faced during software development. These solutions were obtained by trial and error by numerous software developers over quite a substantial period of time.
This tutorial will take you through step by step approach and examples using Java while learning Design Pattern concepts.
Audience
This reference has been prepared for the experienced developers to provide best solutions to certain problems faced during software development and for un-experienced developers to learn software design in an easy and faster way.
Prerequisites
Before you start proceeding with this tutorial, we make an assumption that you are already aware of the basic concepts of Java programming.
Copyright & Disclaimer
Copyright 2015 by Tutorials Point (I) Pvt. Ltd.
All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish any contents or a part of contents of this e-book in any manner without written consent of the publisher.
We strive to update the contents of our website and tutorials as timely and as precisely as possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our website or its contents including this tutorial. If you discover any errors on our website or in this tutorial, please notify us at
ii
Table of Contents
About the Tutorial ... i
Audience ... i
Prerequisites ... i
Copyright & Disclaimer ... i
Table of Contents ... ii
1.
DESIGN PATTERN OVERVIEW ... 1
What is Gang of Four (GOF)? ... 1
Usage of Design Pattern ... 1
Types of Design Patterns ... 1
2.
FACTORY PATTERN ... 3
Implementation ... 3
3.
ABSTRACT FACTORY PATTERN ... 7
Implementation ... 7
4.
SINGLETON PATTERN ... 15
Implementation ... 155.
BUILDER PATTERN ... 18
Implementation ... 186.
PROTOTYPE PATTERN ... 26
Implementation ... 267.
ADAPTER PATTERN ... 32
Implementation ... 328.
BRIDGE PATTERN ... 38
Implementation ... 38iii
9.
FILTER PATTERN ... 42
Implementation ... 4210.
COMPOSITE PATTERN ... 50
Implementation ... 5011.
DECORATOR PATTERN ... 54
Implementation ... 5412.
FACADE PATTERN ... 59
Implementation ... 5913.
FLYWEIGHT PATTERN ... 63
Implementation ... 6314.
PROXY PATTERN ... 69
Implementation ... 6915.
CHAIN OF RESPONSIBILITY PATTERN ... 72
Implementation ... 72
16.
COMMAND PATTERN ... 77
Implementation ... 7717.
INTERPRETER PATTERN ... 81
Implementation ... 8118.
ITERATOR PATTERN ... 85
Implementation ... 8519.
MEDIATOR PATTERN ... 88
Implementation ... 8820.
MEMENTO PATTERN ... 91
Implementation ... 91iv
21.
OBSERVER PATTERN ... 95
Implementation ... 95
22.
STATE PATTERN ... 100
Implementation ... 100
23.
NULL OBJECT PATTERN ... 104
Implementation ... 104
24.
STRATEGY PATTERN ... 108
Implementation ... 10825.
TEMPLATE PATTERN ... 112
Implementation ... 11226.
VISITOR PATTERN ... 116
Implementation ... 11627.
MVC PATTERN ... 121
Implementation ... 12128.
BUSINESS DELEGATE PATTERN ... 126
Implementation ... 126
29.
COMPOSITE ENTITY PATTERN ... 131
Implementation ... 131
30.
DATA ACCESS OBJECT PATTERN ... 136
Implementation ... 136
31.
FRONT CONTROLLER PATTERN ... 141
Implementation ... 141
32.
INTERCEPTNG FILTER PATTERN ... 145
v
33.
SERVICE LOCATOR PATTERN ... 151
Implementation ... 151
34.
TRANSFER OBJECT PATTERN ... 157
1 Design patterns represent the best practices used by experienced object-oriented software developers. Design patterns are solutions to general problems that software developers faced during software development. These solutions were obtained by trial and error by numerous software developers over quite a substantial period of time.
What is Gang of Four (GOF)?
In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published a book titled Design Patterns - Elements of Reusable
Object-Oriented Software which initiated the concept of Design Pattern in
Software development.
These authors are collectively known as Gang of Four (GOF). According to these authors design patterns are primarily based on the following principles of object orientated design.
Program to an interface not an implementation Favor object composition over inheritance
Usage of Design Pattern
Design Patterns have two main usages in software development.
Common platform for developers
Design patterns provide a standard terminology and are specific to particular scenario. For example, a singleton design pattern signifies the use of single object so all developers familiar with single design pattern will make use of single object and they can tell each other that program is following a singleton pattern.
Best Practices
Design patterns have been evolved over a long period of time and they provide best solutions to certain problems faced during software development. Learning these patterns help unexperienced developers to learn software design in an easy and fast way.
Types of Design Patterns
As per the design pattern reference book Design Patterns - Elements of
Reusable Object-Oriented Software, there are 23 design patterns which can
2 be classified in three categories: Creational, Structural and Behavioral patterns. We will also discuss another category of design pattern: J2EE design patterns.
S.N. Pattern & Description
1 Creational Patterns
These design patterns provide a way to create objects while hiding the creation logic, rather than instantiating objects directly using new operator. This gives more flexibility to the program in deciding which objects need to be created for a given use case.
2 Structural Patterns
These design patterns concern class and object composition. Concept of inheritance is used to compose interfaces and define ways to compose objects to obtain new functionalities.
3 Behavioral Patterns
These design patterns are specifically concerned with communication between objects.
4 J2EE Patterns
These design patterns are specifically concerned with the presentation tier. These patterns are identified by Sun Java Center.
3 Factory pattern is one of most used 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.
In Factory pattern, we create objects without exposing the creation logic to the client and refer to newly created object using a common interface.
Implementation
We are going to create a Shape interface and concrete classes implementing the Shape interface. A factory class ShapeFactory is defined as a next step. FactoryPatternDemo, our demo class, will use ShapeFactory to get a Shape object. It will pass information (CIRCLE / RECTANGLE / SQUARE) to ShapeFactory to get the type of object it needs.
Step 1
Create an interface.
Shape.java
public interface Shape { void draw();
4 }
Step 2
Create concrete classes implementing the same interface.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method."); }
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method."); }
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method."); }
5
Step 3
Create a Factory to generate object of concrete class based on given information.
ShapeFactory.java
public class ShapeFactory {
//use getShape method to get object of type shape 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("SQUARE")){ return new Square();
}
return null; }
}
Step 4
Use the Factory to get object of concrete class by passing an information such as type.
FactoryPatternDemo.java
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//get an object of Circle and call its draw method. Shape shape1 = shapeFactory.getShape("CIRCLE");
6 //call draw method of Circle
shape1.draw();
//get an object of Rectangle and call its draw method. Shape shape2 = shapeFactory.getShape("RECTANGLE");
//call draw method of Rectangle shape2.draw();
//get an object of Square and call its draw method. Shape shape3 = shapeFactory.getShape("SQUARE");
//call draw method of circle shape3.draw();
} }
Step 5
Verify the output.
Inside Circle::draw() method. Inside Rectangle::draw() method. Inside Square::draw() method.
7 Abstract Factory patterns work around a super-factory which creates other factories. This factory is also called as factory of factories. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.
In Abstract Factory pattern, an interface is responsible for creating a factory of related objects without explicitly specifying their classes. Each generated factory can give the objects as per the Factory pattern.
Implementation
We are going to create a Shape and Color interfaces and concrete classes implementing these interfaces. We create an abstract factory class AbstractFactory as next step. Factory classes ShapeFactory and ColorFactory are defined where each factory extends AbstractFactory. A factory creator/generator class FactoryProducer is created.
AbstractFactoryPatternDemo, our demo class, uses FactoryProducer to get an AbstractFactory object. It will pass information (CIRCLE / RECTANGLE / SQUARE for Shape) to AbstractFactory to get the type of object it needs. It also passes information (RED / GREEN / BLUE for Color) to AbstractFactory to get the type of object it needs.
8
Step 1
Create an interface for Shapes.
Shape.java
public interface Shape { void draw();
}
Step 2
Create concrete classes implementing the same interface.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
9 }
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method."); }
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method."); }
}
Step 3
Create an interface for Colors.
Color.java
public interface Color { void fill();
}
Step4
10
Red.java
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method."); }
}
Green.java
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method."); }
}
Blue.java
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method."); }
}
Step 5
Create an Abstract class to get factories for Color and Shape Objects.
AbstractFactory.java
public abstract class AbstractFactory { abstract Color getColor(String color);
11 abstract Shape getShape(String shape) ;
}
Step 6
Create Factory classes extending AbstractFactory to generate object of concrete class based on given information.
ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
@Override
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("SQUARE")){ return new Square();
}
return null; }
@Override
Color getColor(String color) { return null;
} }
12
ColorFactory.java
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){ return null;
}
@Override
Color getColor(String color) { if(color == null){
return null; }
if(color.equalsIgnoreCase("RED")){ return new Red();
} else if(color.equalsIgnoreCase("GREEN")){ return new Green();
} else if(color.equalsIgnoreCase("BLUE")){ return new Blue();
}
return null; }
}
Step 7
Create a Factory generator/producer class to get factories by passing an information such as Shape or Color
FactoryProducer.java
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){ if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
13 return new ColorFactory();
}
return null; }
}
Step 8
Use the FactoryProducer to get AbstractFactory in order to get factories of concrete classes by passing an information such as type.
AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo { public static void main(String[] args) {
//get shape factory
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//get an object of Shape Circle
Shape shape1 = shapeFactory.getShape("CIRCLE");
//call draw method of Shape Circle shape1.draw();
//get an object of Shape Rectangle
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//call draw method of Shape Rectangle shape2.draw();
//get an object of Shape Square
Shape shape3 = shapeFactory.getShape("SQUARE");
//call draw method of Shape Square shape3.draw();
14 //get color factory
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//get an object of Color Red
Color color1 = colorFactory.getColor("RED");
//call fill method of Red color1.fill();
//get an object of Color Green
Color color2 = colorFactory.getColor("Green");
//call fill method of Green color2.fill();
//get an object of Color Blue
Color color3 = colorFactory.getColor("BLUE");
//call fill method of Color Blue color3.fill();
} }
Step 9
Verify the output.
Inside Circle::draw() method. Inside Rectangle::draw() method. Inside Square::draw() method. Inside Red::fill() method. Inside Green::fill() method. Inside Blue::fill() method.
15 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.
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 instantiating the object of the class.
Implementation
We are going to create a SingleObject class which has its constructor as private and a static instance of itself.
SingleObject class provides a static method to get its static instance to outside world. SingletonPatternDemo, our demo class, will use SingleObject class to get a SingleObject object.
16
Step 1
Create a Singleton Class.
SingleObject.java
public class SingleObject {
//create an object of SingleObject
private static SingleObject instance = new SingleObject();
//make the constructor private so that this class cannot be //instantiated
private SingleObject(){}
//Get the only object available
public static SingleObject getInstance(){ return instance;
}
public void showMessage(){
System.out.println("Hello World!"); }
}
Step 2
Get the only object from the singleton class.
SingletonPatternDemo.java
public class SingletonPatternDemo {
public static void main(String[] args) {
//illegal construct
//Compile Time Error: The constructor SingleObject() is not visible
17 //Get the only object available
SingleObject object = SingleObject.getInstance();
//show the message object.showMessage(); }
}
Step 3
Verify the output. Hello World!
18 Builder pattern builds a complex object using simple objects and using a step by step approach. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.
A Builder class builds the final object step by step. This builder is independent of other objects.
Implementation
We have considered a business case of fast-food restaurant where a typical meal could be a burger and a cold drink. Burger could be either a Veg Burger or Chicken Burger and will be packed by a wrapper. Cold drink could be either a coke or pepsi and will be packed in a bottle.
We are going to create an Item interface representing food items such as burgers and cold drinks and concrete classes implementing the Item interface and a Packing interface representing packaging of food items and concrete classes implementing the Packing interface as burger would be packed in wrapper and cold drink would be packed as bottle.
We then create a Meal class having ArrayList of Item and a MealBuilder to build different types of Meal objects by combining Item. BuilderPatternDemo, our demo class, will use MealBuilder to build a Meal.
19
Step 1
Create an interface Item representing food item and packing.
Item.java
public interface Item { public String name(); public Packing packing(); public float price(); }
Packing.java
public interface Packing { public String pack(); }
20
Step 2
Create concrete classes implementing the 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
Create abstract classes implementing the item interface providing default functionalities.
Burger.java
public abstract class Burger implements Item {
@Override
public Packing packing() { return new Wrapper(); }
21 public abstract float price();
}
ColdDrink.java
public abstract class ColdDrink implements Item {
@Override
public Packing packing() { return new Bottle();
}
@Override
public abstract float price(); }
Step 4
Create concrete classes extending Burger and ColdDrink classes
VegBurger.java
public class VegBurger extends Burger {
@Override
public float price() { return 25.0f;
}
@Override
public String name() { return "Veg Burger"; }
22
ChickenBurger.java
public class ChickenBurger extends Burger {
@Override
public float price() { return 50.5f;
}
@Override
public String name() { return "Chicken Burger"; }
}
Coke.java
public class Coke extends ColdDrink {
@Override
public float price() { return 30.0f;
}
@Override
public String name() { return "Coke"; }
}
Pepsi.java
public class Pepsi extends ColdDrink {
23 public float price() {
return 35.0f; }
@Override
public String name() { return "Pepsi"; }
}
Step 5
Create a Meal class having Item objects defined above.
Meal.java
import java.util.ArrayList; import java.util.List;
public class Meal {
private List<Item> items = new ArrayList<Item>();
public void addItem(Item item){ items.add(item);
}
public float getCost(){ float cost = 0.0f;
for (Item item : items) { cost += item.price(); }
return cost; }
public void showItems(){ for (Item item : items) {
24 System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packing().pack()); System.out.println(", Price : "+item.price());
} } }
Step 6
Create a MealBuilder class, the actual builder class responsible to create Meal objects.
MealBuilder.java
public class MealBuilder {
public Meal prepareVegMeal (){ Meal meal = new Meal();
meal.addItem(new VegBurger()); meal.addItem(new Coke()); return meal;
}
public Meal prepareNonVegMeal (){ Meal meal = new Meal();
meal.addItem(new ChickenBurger()); meal.addItem(new Pepsi()); return meal; } }
Step 7
BuiderPatternDemo uses MealBuider to demonstrate builder pattern.
BuilderPatternDemo.java
25 public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal(); System.out.println("Veg Meal");
vegMeal.showItems();
System.out.println("Total Cost: " +vegMeal.getCost());
Meal nonVegMeal = mealBuilder.prepareNonVegMeal(); System.out.println("\n\nNon-Veg Meal");
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost()); }
}
Step 8
Verify the output. Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0 Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0
Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5 Item : Pepsi, Packing : Bottle, Price : 35.0
26 Prototype pattern refers to creating duplicate object while keeping performance in mind. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.
This pattern involves implementing a prototype interface which tells to create a clone of the current object. This pattern is used when creation of object directly is costly. For example, an object is to be created after a costly database operation. We can cache the object, return its clone on next request and update the database as and when needed thus reducing database calls.
Implementation
We are 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.
PrototypePatternDemo, our demo class, will use ShapeCache class to get a Shape object.
27
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;
}
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; } }
28
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."); }
}
Square.java
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";
29 }
@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) { 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);
30 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 aHashtable.
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()); }
}
Step 5
Verify the output. Shape : Circle Shape : Square Shape : Rectangle
32 Adapter pattern works as a bridge between two incompatible interfaces. This type of design pattern comes under structural pattern as this pattern combines the capability of two independent interfaces.
This pattern involves a single class which is responsible to join functionalities of independent or incompatible interfaces. A real life example could be a case of card reader which acts as an adapter between memory card and a laptop. You plugin the memory card into card reader and card reader into the laptop so that memory card can be read via laptop.
We are demonstrating use of Adapter pattern via following example in which an audio player device can play mp3 files only and wants to use an advanced audio player capable of playing vlc and mp4 files.
Implementation
We have a MediaPlayer interface and a concrete class AudioPlayer implementing theMediaPlayer interface. AudioPlayer can play mp3 format audio files by default. We are having another interface AdvancedMediaPlayer and concrete classes implementing the AdvancedMediaPlayer interface. These classes can play vlc and mp4 format files.
We want to make AudioPlayer to play other formats as well. To attain this, we have created an adapter class MediaAdapter which implements the MediaPlayer interface and uses AdvancedMediaPlayer objects to play the required format.
AudioPlayer uses the adapter class MediaAdapter passing it the desired audio type without knowing the actual class which can play the desired format. AdapterPatternDemo, our demo class, will use AudioPlayer class to play various formats.
33
Step 1
Create interfaces for Media Player and Advanced Media Player.
MediaPlayer.java
public interface MediaPlayer {
public void play(String audioType, String fileName); }
AdvancedMediaPlayer.java
public interface AdvancedMediaPlayer { public void playVlc(String fileName); public void playMp4(String fileName); }
Step 2
34
VlcPlayer.java
public class VlcPlayer implements AdvancedMediaPlayer{ @Override
public void playVlc(String fileName) {
System.out.println("Playing vlc file. Name: "+ fileName); }
@Override
public void playMp4(String fileName) { //do nothing
} }
Mp4Player.java
public class Mp4Player implements AdvancedMediaPlayer{
@Override
public void playVlc(String fileName) { //do nothing
}
@Override
public void playMp4(String fileName) {
System.out.println("Playing mp4 file. Name: "+ fileName); }
}
Step 3
Create adapter class implementing the MediaPlayer interface.
MediaAdapter.java
35 AdvancedMediaPlayer advancedMusicPlayer;
public MediaAdapter(String audioType){ if(audioType.equalsIgnoreCase("vlc") ){ advancedMusicPlayer = new VlcPlayer(); } else if (audioType.equalsIgnoreCase("mp4")){ advancedMusicPlayer = new Mp4Player(); }
}
@Override
public void play(String audioType, String fileName) { if(audioType.equalsIgnoreCase("vlc")){ advancedMusicPlayer.playVlc(fileName); }else if(audioType.equalsIgnoreCase("mp4")){ advancedMusicPlayer.playMp4(fileName); } } }
Step 4
Create concrete class implementing the MediaPlayer interface.
AudioPlayer.java
public class AudioPlayer implements MediaPlayer { MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
//inbuilt support to play mp3 music files if(audioType.equalsIgnoreCase("mp3")){
36 }
//mediaAdapter is providing support to play other file formats else if(audioType.equalsIgnoreCase("vlc")
|| audioType.equalsIgnoreCase("mp4")){ mediaAdapter = new MediaAdapter(audioType); mediaAdapter.play(audioType, fileName); }
else{
System.out.println("Invalid media. "+ audioType + " format not supported"); }
} }
Step 5
Use the AudioPlayer to play different types of audio formats.
AdapterPatternDemo.java
public class AdapterPatternDemo {
public static void main(String[] args) {
AudioPlayer audioPlayer = new AudioPlayer();
audioPlayer.play("mp3", "beyond the horizon.mp3"); audioPlayer.play("mp4", "alone.mp4");
audioPlayer.play("vlc", "far far away.vlc"); audioPlayer.play("avi", "mind me.avi"); }
}
Step 6
Verify the output.
Playing mp3 file. Name: beyond the horizon.mp3 Playing mp4 file. Name: alone.mp4
37 Playing vlc file. Name: far far away.vlc
38 Bridge is used when we need to decouple an abstraction from its implementation so that the two can vary independently. This type of design pattern comes under structural pattern as this pattern decouples implementation class and abstract class by providing a bridge structure between them.
This pattern involves an interface which acts as a bridge which makes the functionality of concrete classes independent from interface implementer classes. Both types of classes can be altered structurally without affecting each other. We are demonstrating use of Bridge pattern via following example in which a circle can be drawn in different colors using same abstract class method but different bridge implementer classes.
Implementation
We have a DrawAPI interface which is acting as a bridge implementer and concrete classes RedCircle, GreenCircle implementing the DrawAPI interface. Shape is an abstract class and will use object of DrawAPI. BridgePatternDemo, our demo class, will use Shape class to draw different colored circle.
Step 1
Create bridge implementer interface.
39
DrawAPI.java
public interface DrawAPI {
public void drawCircle(int radius, int x, int y); }
Step 2
Create concrete bridge implementer classes implementing the DrawAPI interface.
RedCircle.java
public class RedCircle implements DrawAPI { @Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: red, radius: " + radius +", x: " +x+", "+ y +"]");
} }
GreenCircle.java
public class GreenCircle implements DrawAPI { @Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: green, radius: " + radius +", x: " +x+", "+ y +"]");
} }
Step 3
Create an abstract class Shape using the DrawAPI interface.
Shape.java
public abstract class Shape { protected DrawAPI drawAPI;
40 this.drawAPI = drawAPI;
}
public abstract void draw(); }
Step 4
Create concrete class implementing the Shape interface.
Circle.java
public class Circle extends Shape { private int x, y, radius;
public Circle(int x, int y, int radius, DrawAPI drawAPI) { super(drawAPI);
this.x = x; this.y = y;
this.radius = radius; }
public void draw() {
drawAPI.drawCircle(radius,x,y); }
}
Step 5
Use the Shape and DrawAPI classes to draw different colored circles.
BridgePatternDemo.java
public class BridgePatternDemo {
public static void main(String[] args) {
Shape redCircle = new Circle(100,100, 10, new RedCircle()); Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
41 greenCircle.draw();
} }
Step 6
Verify the output.
Drawing Circle[ color: red, radius: 10, x: 100, 100] Drawing Circle[ color: green, radius: 10, x: 100, 100]
42 Filter pattern or Criteria pattern is a design pattern that enables developers to filter a set of objects using different criteria and chaining them in a decoupled way through logical operations. This type of design pattern comes under structural pattern as this pattern combines multiple criteria to obtain single criteria.
Implementation
We are going to create a Person object, Criteria interface and concrete classes implementing this interface to filter list of Person objects. CriteriaPatternDemo, our demo class, uses Criteria objects to filter List of Person objects based on various criteria and their combinations.
Step 1
Create a class on which criteria is to be applied.
43
Person.java
public class Person {
private String name; private String gender;
private String maritalStatus;
public Person(String name, String gender, String maritalStatus){ this.name = name;
this.gender = gender;
this.maritalStatus = maritalStatus; }
public String getName() { return name;
}
public String getGender() { return gender;
}
public String getMaritalStatus() { return maritalStatus;
} }
Step 2
Create an interface for Criteria.
Criteria.java
import java.util.List;
public interface Criteria {
public List<Person> meetCriteria(List<Person> persons); }
44
Step 3
Create concrete classes implementing the Criteria interface.
CriteriaMale.java
import java.util.ArrayList; import java.util.List;
public class CriteriaMale implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) { List<Person> malePersons = new ArrayList<Person>(); for (Person person : persons) {
if(person.getGender().equalsIgnoreCase("MALE")){ malePersons.add(person); } } return malePersons; } }
CriteriaFemale.java
import java.util.ArrayList; import java.util.List;public class CriteriaFemale implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) { List<Person> femalePersons = new ArrayList<Person>(); for (Person person : persons) {
if(person.getGender().equalsIgnoreCase("FEMALE")){ femalePersons.add(person);
45 } return femalePersons; } }
CriteriaSingle.java
import java.util.ArrayList; import java.util.List;public class CriteriaSingle implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) { List<Person> singlePersons = new ArrayList<Person>(); for (Person person : persons) {
if(person.getMaritalStatus().equalsIgnoreCase("SINGLE")){ singlePersons.add(person); } } return singlePersons; } }
AndCriteria.java
import java.util.List;public class AndCriteria implements Criteria {
private Criteria criteria; private Criteria otherCriteria;
public AndCriteria(Criteria criteria, Criteria otherCriteria) { this.criteria = criteria;
46 }
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
return otherCriteria.meetCriteria(firstCriteriaPersons); }
}
OrCriteria.java
import java.util.List;
public class OrCriteria implements Criteria {
private Criteria criteria; private Criteria otherCriteria;
public OrCriteria(Criteria criteria, Criteria otherCriteria) { this.criteria = criteria;
this.otherCriteria = otherCriteria; }
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaItems = criteria.meetCriteria(persons); List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);
for (Person person : otherCriteriaItems) { if(!firstCriteriaItems.contains(person)){ firstCriteriaItems.add(person); } } return firstCriteriaItems; }
47 }
Step 4
Use different Criteria and their combination to filter out persons.
CriteriaPatternDemo.java
public class CriteriaPatternDemo {
public static void main(String[] args) {
List<Person> persons = new ArrayList<Person>();
persons.add(new Person("Robert","Male", "Single")); persons.add(new Person("John", "Male", "Married")); persons.add(new Person("Laura", "Female", "Married")); persons.add(new Person("Diana", "Female", "Single")); persons.add(new Person("Mike", "Male", "Single")); persons.add(new Person("Bobby", "Male", "Single"));
Criteria male = new CriteriaMale(); Criteria female = new CriteriaFemale(); Criteria single = new CriteriaSingle();
Criteria singleMale = new AndCriteria(single, male); Criteria singleOrFemale = new OrCriteria(single, female);
System.out.println("Males: "); printPersons(male.meetCriteria(persons)); System.out.println("\nFemales: "); printPersons(female.meetCriteria(persons)); System.out.println("\nSingle Males: "); printPersons(singleMale.meetCriteria(persons)); System.out.println("\nSingle Or Females: "); printPersons(singleOrFemale.meetCriteria(persons));
48 }
public static void printPersons(List<Person> persons){ for (Person person : persons) {
System.out.println("Person : [ Name : " + person.getName() +", Gender : " + person.getGender()
+", Marital Status : " + person.getMaritalStatus() +" ]");
} } }
Step 5
Verify the output. Males:
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] Person : [ Name : John, Gender : Male, Marital Status : Married ] Person : [ Name : Mike, Gender : Male, Marital Status : Single ] Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Females:
Person : [ Name : Laura, Gender : Female, Marital Status : Married ] Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Single Males:
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] Person : [ Name : Mike, Gender : Male, Marital Status : Single ] Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Single Or Females:
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] Person : [ Name : Diana, Gender : Female, Marital Status : Single ] Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
49 Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
50 Composite pattern is used where we need to treat a group of objects in similar way as a single object. Composite pattern composes objects in term of a tree structure to represent part as well as whole hierarchy. This type of design pattern comes under structural pattern as this pattern creates a tree structure of a group of objects.
This pattern creates a class that contains a group of its own objects. This class provides ways to modify its group of same objects.
We are demonstrating use of composite pattern via following example in which we will show employees hierarchy of an organization.
Implementation
We have a class Employee which acts as composite pattern actor class. CompositePatternDemo, our demo class, will use Employee class to add department level hierarchy and print all employees.
51
Step 1
Create Employee class having list of Employee objects.
Employee.java
import java.util.ArrayList; import java.util.List;
public class Employee { private String name; private String dept; private int salary;
private List<Employee> subordinates;
// constructor
public Employee(String name,String dept, int sal) { this.name = name;
this.dept = dept; this.salary = sal;
subordinates = new ArrayList<Employee>(); }
public void add(Employee e) { subordinates.add(e);
}
public void remove(Employee e) { subordinates.remove(e);
}
public List<Employee> getSubordinates(){ return subordinates;
}
52 return ("Employee :[ Name : "+ name
+", dept : "+ dept + ", salary :" + salary+" ]");
} }
Step 2
Use the Employee class to create and print employee hierarchy.
CompositePatternDemo.java
public class CompositePatternDemo {
public static void main(String[] args) {
Employee CEO = new Employee("John","CEO", 30000);
Employee headSales = new Employee("Robert","Head Sales", 20000);
Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
Employee clerk1 = new Employee("Laura","Marketing", 10000); Employee clerk2 = new Employee("Bob","Marketing", 10000);
Employee salesExecutive1 = new Employee("Richard","Sales", 10000); Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
CEO.add(headSales); CEO.add(headMarketing); headSales.add(salesExecutive1); headSales.add(salesExecutive2); headMarketing.add(clerk1); headMarketing.add(clerk2);
53 System.out.println(CEO);
for (Employee headEmployee : CEO.getSubordinates()) { System.out.println(headEmployee);
for (Employee employee : headEmployee.getSubordinates()) { System.out.println(employee); } } } }
Step 3
Verify the output.
Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ] Employee :[ Name : Richard, dept : Sales, salary :10000 ] Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ] Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
54 Decorator pattern allows a user to add new functionality to an existing object without altering its structure. This type of design pattern comes under structural pattern as this pattern acts as a wrapper to existing class.
This pattern creates a decorator class which wraps the original class and provides additional functionality keeping class methods signature intact.
We are demonstrating the use of decorator pattern via following example in which we will decorate a shape with some color without alter shape class.
Implementation
We are going to create a Shape interface and concrete classes implementing the Shape interface. We will then create an abstract decorator class ShapeDecorator implementing the Shape interface and having Shape object as its instance variable.
RedShapeDecorator is concrete class implementing ShapeDecorator.
DecoratorPatternDemo, our demo class, will use RedShapeDecorator to decorate Shape objects.
55
Step 1
Create an interface.
Shape.java
public interface Shape { void draw();
}
Step 2
Create concrete classes implementing the same interface.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Shape: Rectangle"); }
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Shape: Circle"); }
}
Step 3
Create abstract decorator class implementing the Shape interface.
ShapeDecorator.java
56 protected Shape decoratedShape;
public ShapeDecorator(Shape decoratedShape){ this.decoratedShape = decoratedShape; }
public void draw(){
decoratedShape.draw(); }
}
Step 4
Create concrete decorator class extending the ShapeDecorator class.
RedShapeDecorator.java
public class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) { super(decoratedShape);
}
@Override
public void draw() {
decoratedShape.draw(); setRedBorder(decoratedShape); }
private void setRedBorder(Shape decoratedShape){ System.out.println("Border Color: Red"); }
57
Step 5
Use the RedShapeDecorator to decorate Shape objects.
DecoratorPatternDemo.java
public class DecoratorPatternDemo {
public static void main(String[] args) {
Shape circle = new Circle();
Shape redCircle = new RedShapeDecorator(new Circle());
Shape redRectangle = new RedShapeDecorator(new Rectangle()); System.out.println("Circle with normal border");
circle.draw();
System.out.println("\nCircle of red border"); redCircle.draw();
System.out.println("\nRectangle of red border"); redRectangle.draw();
} }
Step 6
Verify the output.
Circle with normal border Shape: Circle
Circle of red border Shape: Circle
Border Color: Red
58 Shape: Rectangle
59 Facade pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. This type of design pattern comes under structural pattern as this pattern adds an interface to existing system to hide its complexities.
This pattern involves a single class which provides simplified methods required by client and delegates calls to methods of existing system classes.
Implementation
We are going to create a Shape interface and concrete classes implementing the Shape interface. A facade class ShapeMaker is defined as a next step.
ShapeMaker class uses the concrete classes to delegate calls to these classes. FacadePatternDemo, our demo class, will use ShapeMaker class to show the results.
Step 1
Create an interface.
Shape.java
public interface Shape { void draw();
60 }
Step 2
Create concrete classes implementing the same interface.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Rectangle::draw()"); }
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Square::draw()"); }
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle::draw()"); }
61
Step 3
Create a facade class.
ShapeMaker.java
public class ShapeMaker { private Shape circle; private Shape rectangle; private Shape square;
public ShapeMaker() { circle = new Circle();
rectangle = new Rectangle(); square = new Square();
}
public void drawCircle(){ circle.draw();
}
public void drawRectangle(){ rectangle.draw();
}
public void drawSquare(){ square.draw();
} }
Step 4
Use the facade to draw various types of shapes.
FacadePatternDemo.java
public class FacadePatternDemo {
public static void main(String[] args) { ShapeMaker shapeMaker = new ShapeMaker();
62 shapeMaker.drawCircle(); shapeMaker.drawRectangle(); shapeMaker.drawSquare(); } }
Step 5
Verify the output. Circle::draw() Rectangle::draw() Square::draw()
63 Flyweight pattern is primarily used to reduce the number of objects created and to decrease memory footprint and increase performance. This type of design pattern comes under structural pattern as this pattern provides ways to decrease object count thus improving the object structure of application.
Flyweight pattern tries to reuse already existing similar kind objects by storing them and creates new object when no matching object is found. We will demonstrate this pattern by drawing 20 circles of different locations but we will create only 5 objects. Only 5 colors are available so color property is used to check already existing Circle objects.
Implementation
We are going to create a Shape interface and concrete class Circle implementing the Shape interface. A factory class ShapeFactory is defined as a next step. ShapeFactory has a HashMap of Circle having key as color of the Circle object. Whenever a request comes to create a circle of particular color to ShapeFactory, it checks the circle object in its HashMap. If object of Circle is found, that object is returned otherwise a new object is created, stored in hashmap for future use, and returned to client.
FlyWeightPatternDemo, our demo class, will use ShapeFactory to get a Shape object. It will pass information (red / green / blue/ black / white) to ShapeFactory to get the circle of desired color it needs.
64
Step 1
Create an interface.
Shape.java
public interface Shape { void draw();
}
Step 2
Create concrete class implementing the same interface.
Circle.java
public class Circle implements Shape { private String color;
private int x; private int y; private int radius;
65 public Circle(String color){
this.color = color; }
public void setX(int x) { this.x = x;
}
public void setY(int y) { this.y = y;
}
public void setRadius(int radius) { this.radius = radius;
}
@Override
public void draw() {
System.out.println("Circle: Draw() [Color : " + color +", x : " + x +", y :" + y +", radius :" + radius); }
}
Step 3
Create a factory to generate the object of concrete class based on given information.
ShapeFactory.java
import java.util.HashMap;
public class ShapeFactory {
66 public static Shape getCircle(String color) {
Circle circle = (Circle)circleMap.get(color);
if(circle == null) {
circle = new Circle(color); circleMap.put(color, circle);
System.out.println("Creating circle of color : " + color); }
return circle; }
}
Step 4
Use the factory to get object of concrete class by passing an information such as color.
FlyweightPatternDemo.java
public class FlyweightPatternDemo {
private static final String colors[] =
{ "Red", "Green", "Blue", "White", "Black" }; public static void main(String[] args) {
for(int i=0; i < 20; ++i) { Circle circle = (Circle)ShapeFactory.getCircle(getRandomColor()); circle.setX(getRandomX()); circle.setY(getRandomY()); circle.setRadius(100); circle.draw(); } }
private static String getRandomColor() {
return colors[(int)(Math.random()*colors.length)]; }
67 private static int getRandomX() {
return (int)(Math.random()*100 ); }
private static int getRandomY() { return (int)(Math.random()*100); }
}
Step 5
Verify the output.
Creating circle of color : Black
Circle: Draw() [Color : Black, x : 36, y :71, radius :100 Creating circle of color : Green
Circle: Draw() [Color : Green, x : 27, y :27, radius :100 Creating circle of color : White
Circle: Draw() [Color : White, x : 64, y :10, radius :100 Creating circle of color : Red
Circle: Draw() [Color : Red, x : 15, y :44, radius :100 Circle: Draw() [Color : Green, x : 19, y :10, radius :100 Circle: Draw() [Color : Green, x : 94, y :32, radius :100 Circle: Draw() [Color : White, x : 69, y :98, radius :100 Creating circle of color : Blue
Circle: Draw() [Color : Blue, x : 13, y :4, radius :100 Circle: Draw() [Color : Green, x : 21, y :21, radius :100 Circle: Draw() [Color : Blue, x : 55, y :86, radius :100 Circle: Draw() [Color : White, x : 90, y :70, radius :100 Circle: Draw() [Color : Green, x : 78, y :3, radius :100 Circle: Draw() [Color : Green, x : 64, y :89, radius :100 Circle: Draw() [Color : Blue, x : 3, y :91, radius :100 Circle: Draw() [Color : Blue, x : 62, y :82, radius :100 Circle: Draw() [Color : Green, x : 97, y :61, radius :100 Circle: Draw() [Color : Green, x : 86, y :12, radius :100 Circle: Draw() [Color : Green, x : 38, y :93, radius :100
68 Circle: Draw() [Color : Red, x : 76, y :82, radius :100
69 In proxy pattern, a class represents functionality of another class. This type of design pattern comes under structural pattern.
In proxy pattern, we create object having original object to interface its functionality to outer world.
Implementation
We are going to create an Image interface and concrete classes implementing the Image interface. ProxyImage is a proxy class to reduce memory footprint of RealImage object loading.
ProxyPatternDemo, our demo class, will use ProxyImage to get an Image object to load and display as it needs.
Step 1
Create an interface.
Image.java
public interface Image { void display();
}
70
Step 2
Create concrete classes implementing the same interface.
RealImage.java
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName){ this.fileName = fileName;
loadFromDisk(fileName); }
@Override
public void display() {
System.out.println("Displaying " + fileName); }
private void loadFromDisk(String fileName){ System.out.println("Loading " + fileName); }
}
ProxyImage.java
public class ProxyImage implements Image{
private RealImage realImage; private String fileName;
public ProxyImage(String fileName){ this.fileName = fileName;
}
71 public void display() {
if(realImage == null){
realImage = new RealImage(fileName); }
realImage.display(); }
}
Step 3
Use the ProxyImage to get object of RealImage class when required.
ProxyPatternDemo.java
public class ProxyPatternDemo {
public static void main(String[] args) {
Image image = new ProxyImage("test_10mb.jpg");
//image will be loaded from disk image.display();
System.out.println("");
//image will not be loaded from disk image.display();
} }
Step 4
Verify the output.
Loading test_10mb.jpg Displaying test_10mb.jpg
72 As the name suggests, the chain of responsibility pattern creates a chain of receiver objects for a request. This pattern decouples sender and receiver of a request based on type of request. This pattern comes under behavioral patterns. In this pattern, normally each receiver contains reference to another receiver. If one object cannot handle the request then it passes the same to the next receiver and so on.
Implementation
We have created an abstract class AbstractLogger with a level of logging. Then we have created three types of loggers extending the AbstractLogger. Each logger checks the level of message to its level and prints accordingly otherwise does not print and pass the message to its next logger.
73
Step 1
Create an abstract logger class.
AbstractLogger.java
public abstract class AbstractLogger { public static int INFO = 1;
public static int DEBUG = 2; public static int ERROR = 3;
protected int level;
//next element in chain or responsibility protected AbstractLogger nextLogger;
public void setNextLogger(AbstractLogger nextLogger){ this.nextLogger = nextLogger;
}
public void logMessage(int level, String message){ if(this.level <= level){ write(message); } if(nextLogger !=null){ nextLogger.logMessage(level, message); } }
abstract protected void write(String message);
74
Step 2
Create concrete classes extending the logger.
ConsoleLogger.java
public class ConsoleLogger extends AbstractLogger {
public ConsoleLogger(int level){ this.level = level;
}
@Override
protected void write(String message) {
System.out.println("Standard Console::Logger: " + message); }
}
ErrorLogger.java
public class ErrorLogger extends AbstractLogger {
public ErrorLogger(int level){ this.level = level;
}
@Override
protected void write(String message) {
System.out.println("Error Console::Logger: " + message); }
}
FileLogger.java
public class FileLogger extends AbstractLogger {
public FileLogger(int level){ this.level = level;
75 }
@Override
protected void write(String message) {
System.out.println("File::Logger: " + message); }
}
Step 3
Create different types of loggers. Assign them error levels and set next logger in each logger. Next logger in each logger represents the part of the chain.
ChainPatternDemo.java
public class ChainPatternDemo {
private static AbstractLogger getChainOfLoggers(){
AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG); AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
errorLogger.setNextLogger(fileLogger); fileLogger.setNextLogger(consoleLogger);
return errorLogger; }
public static void main(String[] args) {
AbstractLogger loggerChain = getChainOfLoggers();
loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
76 "This is a debug level information.");
loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
} }
Step 4
Verify the output.
Standard Console::Logger: This is an information. File::Logger: This is a debug level information.
Standard Console::Logger: This is a debug level information. Error Console::Logger: This is an error information.
File::Logger: This is an error information.
77 Command pattern is a data driven design pattern and falls under behavioral pattern category. A request is wrapped under an object as command and passed to invoker object. Invoker object looks for the appropriate object which can handle this command and passes the command to the corresponding object which executes it.
Implementation
We have created an interface Order which is acting as a command. We have created a Stock class which acts as a request. We have concrete command classes BuyStock and SellStock implementing Order interface which will do actual command processing. A class Broker is created which acts as an invoker object. It can take and place orders.
Broker object uses command pattern to identify which object will execute which command based on the type of command. CommandPatternDemo, our demo class, will use Broker class to demonstrate command pattern.
78
Step 1
Create a command interface.
Order.java
public interface Order { void execute();
}
Step 2
Create a request class.
Stock.java
public class Stock {
private String name = "ABC"; private int quantity = 10;
public void buy(){
System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] bought"); }
public void sell(){
System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");
} }
Step 3
Create concrete classes implementing the Order interface.
BuyStock.java
public class BuyStock implements Order { private Stock abcStock;
79 public BuyStock(Stock abcStock){
this.abcStock = abcStock; }
public void execute() { abcStock.buy(); }
}
SellStock.java
public class SellStock implements Order { private Stock abcStock;
public SellStock(Stock abcStock){ this.abcStock = abcStock; }
public void execute() { abcStock.sell(); }
}
Step 4
Create command invoker class.
Broker.java
import java.util.ArrayList; import java.util.List;
public class Broker {
private List<Order> orderList = new ArrayList<Order>();
