Refer: http://www.tutorialspoint.com/design_pattern/design_pattern_overview.htm
====== Software Design Pattern ======
**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.

**Types of Desing Pattern**:As per the design pattern reference book Design Patterns - Elements of Reusable Object-Oriented Software , there are 23 design patterns. These patterns can be classified in three categories: Creational, Structural and behavioral patterns
^S.N.^Name^Pattern & Description^
|1|**Creational Patterns**|These design patterns provides **way to create objects while hiding the creation logic**, rather than instantiating objects directly using new opreator. This gives program more flexibility 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.|
===== Creational Pattern: Factory Pattern =====
Factory pattern is one of most used design pattern in Java. This type of design pattern comes under creational pattern as **this pattern provides one of the best ways to create an object**.
==== Design ====
{{:other:factory_pattern_uml_diagram.jpg|}}
==== Implementation ====
  - Step 1: Create an interface **Shape.java**:<code java>
public interface Shape {
   void draw();
}
</code>
  - Step 2: Create **concrete classes** implementing the same interface.
    * Rectangle.java<code java>
public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
</code>
    * Square.java<code java>
public class Square implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
</code>
    * Circle.java<code java>
public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}
</code>
  - Step 3: Create a Factory to generate object of concrete class based on given information **ShapeFactory.java**<code 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;
   }
}
</code>
  - Step 4: Use the Factory to get object of concrete class by passing an information such as type FactoryPatternDemo.java:<code 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");

      //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();
   }
}
</code>
  - Step 5: Verify the output.<code>
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
</code>
===== creational pattern: Singleton Pattern =====
This class provides a way to access its only object which can be accessed directly without need to instantiate the object of the class.Ensure a class has only one instance, and provide a global point of access to it
==== Design ====
We're going to **create a SingleObject class**. SingleObject class have its constructor as private and **have 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.
{{:other:singleton_pattern_uml_diagram.jpg|}}
==== Implementation ====
  - Step 1: Create a Singleton Class SingleObject.java<code 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!");
   }
}
</code>
  - Step 2: Get the only object from the singleton class SingletonPatternDemo.java<code java>
public class SingletonPatternDemo {
   public static void main(String[] args) {

      //illegal construct
      //Compile Time Error: The constructor SingleObject() is not visible
      //SingleObject object = new SingleObject();

      //Get the only object available
      SingleObject object = SingleObject.getInstance();

      //show the message
      object.showMessage();
   }
}
</code>
  - Step 3: Verify the output<code>
Hello World!
</code>
===== Structural Pattern: Adapter Pattern =====
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.
==== Design ====
We've an interface **MediaPlayer interface** and a concrete class AudioPlayer implementing the MediaPlayer interface. AudioPlayer can **play mp3 format** audio files by default.

We're having another interface **AdvancedMediaPlayer interface** 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've **created an adapter class MediaAdapter** which implements the MediaPlayer interface and uses AdvancedMediaPlayer objects to play the required format.\\
{{:other:adapter_pattern_uml_diagram.jpg|}}\\
{{:other:patternadapter.png|}}
==== Implementation ====
  - Step 1: **Create interfaces** for Media Player and Advanced Media Player 
    * MediaPlayer.java<code java>
public interface MediaPlayer {
   public void play(String audioType, String fileName);
}
</code>
    * AdvancedMediaPlayer.java<code java>
public interface AdvancedMediaPlayer {	
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}
</code>
  - Step 2: Create **concrete classes** implementing the AdvancedMediaPlayer interface
    * VlcPlayer.java<code 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
   }
}
</code>
    * Mp4Player.java<code 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);		
   }
}
</code>
  - Step 3: Create **adapter class** implementing the MediaPlayer interface MediaAdapter.java<code java>
public class MediaAdapter implements MediaPlayer {

   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);
      }
   }
}
</code>
  - Step 4: Create **concrete class implementing the MediaPlayer interface** AudioPlayer.java<code 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")){
         System.out.println("Playing mp3 file. Name: "+ fileName);			
      } 
      //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");
      }
   }   
}
</code>
  - Step 5: Use the AudioPlayer to **play different types of audio formats** AdapterPatternDemo.java<code 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");
   }
}
</code>
  - Step 6: Verify the output<code>
Playing mp3 file. Name: beyond the horizon.mp3
Playing mp4 file. Name: alone.mp4
Playing vlc file. Name: far far away.vlc
Invalid media. avi format not supported
</code>
===== Structural Pattern: Composite Pattern =====
Composite pattern is used where we need to treat a group of objects in similar way as a single object. 
==== Design ====
We've 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.
{{:other:composite_pattern_uml_diagram.jpg|}}
==== Implementation ====
  - Step 1: Create Employee class having list of Employee objects Employee.java<code 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;
   }

   public String toString(){
      return ("Employee :[ Name : "+ name 
      +", dept : "+ dept + ", salary :"
      + salary+" ]");
   }   
}
</code>
  - Step 2: Use the Employee class to create and print employee hierarchy CompositePatternDemo.java<code 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);

      //print all employees of the organization
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }		
   }
}
</code>
  - Step 3: Verify the output<code>
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 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]
</code>
===== Structural Pattern: Decorator pattern =====
Decorator pattern allows to **add new functionality 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**.
==== Design ====
Below are demonstrating use of Decorator pattern via following example in which we'll **decorate a shape** with **some color without alter shape class**.

We're going to create a **Shape interface** and concrete classes implementing the Shape interface. We then create a 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.\\
{{:other:decorator_pattern_uml_diagram.jpg|}}\\
{{:other:patterndecorator.png|}}
==== Implementation ====
  - Step 1: Create an **interface Shape.java**<code java>
public interface Shape {
   void draw();
}
</code>
  - Step 2: Create concrete classes implementing the same interface:
    * Rectangle.java<code java>
public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Shape: Rectangle");
   }
}
</code>
    * Circle.java<code java>
public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Shape: Circle");
   }
}
</code>
  - Step 3: Create **abstract decorator class** implementing the Shape interface **ShapeDecorator.java**<code java>
public abstract class ShapeDecorator implements Shape {
   protected Shape decoratedShape;

   public ShapeDecorator(Shape decoratedShape){
      this.decoratedShape = decoratedShape;
   }

   public void draw(){
      decoratedShape.draw();
   }	
}
</code>
  - Step 4: Create concrete decorator class **extending the ShapeDecorator class RedShapeDecorator.java**<code 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");
   }
}
</code>
  - Step 5: Use the **RedShapeDecorator** to **decorate Shape objects** DecoratorPatternDemo.java<code 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();
   }
}
</code>
  - Step 6: Verify the output<code>
Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red
</code>
===== Behavior Pattern: Iterator Pattern =====
Iterator pattern is very commonly used design pattern in Java and .Net programming environment. This pattern is used to **get a way to access the elements of a collection object** in sequential manner **without any need to know its underlying representation**.
==== Design ====
{{:other:iterator_pattern_uml_diagram.jpg|}}\\
{{:other:iteratorpattern.png|}}
==== Implementation ====
  - Step 1: Create interfaces:
    * Iterator.java<code java>
public interface Iterator {
   public boolean hasNext();
   public Object next();
}
</code>
    * Container.java<code java>
public interface Container {
   public Iterator getIterator();
}
</code>
  - Step 2: Create concrete class implementing the Container interface. This class has inner class NameIterator implementing the Iterator interface NameRepository.java<code java>
public class NameRepository implements Container {
   public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

   @Override
   public Iterator getIterator() {
      return new NameIterator();
   }

   private class NameIterator implements Iterator {

      int index;

      @Override
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }

      @Override
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }		
   }
}
</code>
  - Step 3: Use the NameRepository to get iterator and print names IteratorPatternDemo.java<code java>
public class IteratorPatternDemo {
	
   public static void main(String[] args) {
      NameRepository namesRepository = new NameRepository();

      for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
         String name = (String)iter.next();
         System.out.println("Name : " + name);
      } 	
   }
}
</code>
  - Step 4: Verify the output<code>
Name : Robert
Name : John
Name : Julie
Name : Lora
</code>
===== Behavior Pattern: Observer Pattern =====
Observer pattern is used when there is one to many relationship between objects such as **if one object is modified, its depenedent objects are to be notified automatically**. Observer pattern falls under behavioral pattern category.
==== Design ====
Observer pattern uses three actor classes. **Subject, Observer and Client**. **Subject, an object having methods to attach and de-attach observers to a client object**. We've created classes Subject, Observer abstract class and concrete classes extending the abstract class the Observer.

ObserverPatternDemo, our demo class will use Subject and concrete class objects to show observer pattern in action.\\
{{:other:observer_pattern_uml_diagram.jpg|}}\\
{{:other:patternobserver.png|}}
==== Implementation ====
  - Step 1: Create **Subject class** Subject.java:<code java>
import java.util.ArrayList;
import java.util.List;

public class Subject {
	
   private List<Observer> observers 
      = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
      observers.add(observer);		
   }

   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   } 	
}
</code>
  - Step 2: Create Observer class Observer.java<code java>
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}
</code>
  - Step 3: Create concrete observer classes:
    * BinaryObserver.java<code java>
public class BinaryObserver extends Observer{

   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}
</code>
    * OctalObserver.java<code java>
public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}
</code>
    * HexaObserver.java<code java>
public class HexaObserver extends Observer{

   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Hex String: " 
      + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}
</code>
  - Step 4: Use Subject and concrete observer objects ObserverPatternDemo.java<code java>
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();

      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("First state change: 15");	
      subject.setState(15);
      System.out.println("Second state change: 10");	
      subject.setState(10);
   }
}
</code>
  - Step 5: Verify the output<code>
First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010
</code>
===== Behavior Pattern:State Pattern =====
In State pattern a **class behavior changes based on its state**. This type of design pattern comes under behavior pattern.
==== Design ====
We're going to create a **State interface defining a action** and **concrete state classes implementing the State interface**. Context is a class which carries a State.

StatePatternDemo, our demo class will use Context and **state objects to demonstrate change in Context behavior based on type of state** it is in.\\
{{:other:state_pattern_uml_diagram.jpg|}}\\
{{:other:patternstate.png|}}
==== Implementation ====
  - Step 1: Create an interface Image.java<code java>
public interface State {
   public void doAction(Context context);
}
</code>
  - Step 2: Create concrete classes implementing the same interface 
    * StartState.java<code java>
public class StartState implements State {

   public void doAction(Context context) {
      System.out.println("Player is in start state");
      context.setState(this);	
   }

   public String toString(){
      return "Start State";
   }
}
</code>
    * StopState.java<code java>
public class StopState implements State {

   public void doAction(Context context) {
      System.out.println("Player is in stop state");
      context.setState(this);	
   }

   public String toString(){
      return "Stop State";
   }
}
</code>
  - Step 3: Create Context Class Context.java<code java>
public class Context {
   private State state;

   public Context(){
      state = null;
   }

   public void setState(State state){
      this.state = state;		
   }

   public State getState(){
      return state;
   }
}
</code>
  - Step 4: Use the Context to see change in behaviour when State changes StatePatternDemo.java<code java>
public class StatePatternDemo {
   public static void main(String[] args) {
      Context context = new Context();

      StartState startState = new StartState();
      startState.doAction(context);

      System.out.println(context.getState().toString());

      StopState stopState = new StopState();
      stopState.doAction(context);

      System.out.println(context.getState().toString());
   }
}
</code>
  - Step 5: Verify the output<code>
Player is in start state
Start State
Player is in stop state
Stop State
</code>
===== Model-View-Controller Pattern =====
This pattern is used to separate application's concerns:
  * Model - Model **represents an object** or JAVA POJO carrying data. It can **also have logic to update controller if its data changes**.
  * View - View **represents the visualization of the data** that model contains.
  * Controller - Controller acts on both Model and view. It **controls the data flow into model object** and **updates the view whenever data changes**. It keeps **View and Model separate**.
==== Design ====
We're going to create a **Student object** acting as a model. **StudentView** will be a view class which can print student details on console and **StudentController** is the controller class responsible to store data in Student object and update view StudentView accordingly.

**MVCPatternDemo**, our demo class will use StudentController to **demonstrate use of MVC pattern**.\\
{{:other:mvc_pattern_uml_diagram.jpg|}}\\
{{:other:patternmvc.png|}}
==== Implementation ====
  - Step 1: Create Model Student.java<code java>
public class Student {
   private String rollNo;
   private String name;
   public String getRollNo() {
      return rollNo;
   }
   public void setRollNo(String rollNo) {
      this.rollNo = rollNo;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}
</code>
  - Step 2: Create View StudentView.java<code java>
public class StudentView {
   public void printStudentDetails(String studentName, String studentRollNo){
      System.out.println("Student: ");
      System.out.println("Name: " + studentName);
      System.out.println("Roll No: " + studentRollNo);
   }
}
</code>
  - Step 3: Create Controller StudentController.java<code java>
public class StudentController {
   private Student model;
   private StudentView view;

   public StudentController(Student model, StudentView view){
      this.model = model;
      this.view = view;
   }

   public void setStudentName(String name){
      model.setName(name);		
   }

   public String getStudentName(){
      return model.getName();		
   }

   public void setStudentRollNo(String rollNo){
      model.setRollNo(rollNo);		
   }

   public String getStudentRollNo(){
      return model.getRollNo();		
   }

   public void updateView(){				
      view.printStudentDetails(model.getName(), model.getRollNo());
   }	
}
</code>
  - Step 4: Use the StudentController methods to demonstrate MVC design pattern usage MVCPatternDemo.java<code java>
public class MVCPatternDemo {
   public static void main(String[] args) {

      //fetch student record based on his roll no from the database
      Student model  = retriveStudentFromDatabase();

      //Create a view : to write student details on console
      StudentView view = new StudentView();

      StudentController controller = new StudentController(model, view);

      controller.updateView();

      //update model data
      controller.setStudentName("John");

      controller.updateView();
   }

   private static Student retriveStudentFromDatabase(){
      Student student = new Student();
      student.setName("Robert");
      student.setRollNo("10");
      return student;
   }
}
</code>
  - Step 5: Verify the output<code>
Student: 
Name: Robert
Roll No: 10
Student: 
Name: John
Roll No: 10
</code>
===== Behavior Pattern:Command Pattern =====
==== Design ====
We've created an **interface Order** which is **acting as a command**. We've created a **Stock class** which acts **as a request**. We've concrete command classes **BuyStock and SellStock implementing Order interface** which will do **actual command processing**. A class **Broker** is created which acts **as a invoker object**. It can take order and place orders.

Broker object uses command pattern to identify which object will execute which command based on type of command. CommandPatternDemo, our demo class will use Broker class to demonstrate command pattern.
{{:other:command_pattern_uml_diagram.jpg|}}\\
{{:other:patterncommand.png|}}
==== Implementation ====
  - Step 1: Create a command interface Order.java<code java>
public interface Order {
   void execute();
}
</code>
  - Step 2: Create a request class Stock.java<code 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");
   }
}
</code>
  - Step 3: Create concrete classes implementing the Order interface:
    * BuyStock.java<code java>
public class BuyStock implements Order {
   private Stock abcStock;

   public BuyStock(Stock abcStock){
      this.abcStock = abcStock;
   }

   public void execute() {
      abcStock.buy();
   }
}
</code>
    * SellStock.java<code java>
public class SellStock implements Order {
   private Stock abcStock;

   public SellStock(Stock abcStock){
      this.abcStock = abcStock;
   }

   public void execute() {
      abcStock.sell();
   }
}
</code>
  - Step 4: Create command invoker class Broker.java<code java>
import java.util.ArrayList;
import java.util.List;

   public class Broker {
   private List<Order> orderList = new ArrayList<Order>(); 

   public void takeOrder(Order order){
      orderList.add(order);		
   }

   public void placeOrders(){
      for (Order order : orderList) {
         order.execute();
      }
      orderList.clear();
   }
}
</code>
  - Step 5: Use the Broker class to take and execute commands CommandPatternDemo.java<code java>
public class CommandPatternDemo {
   public static void main(String[] args) {
      Stock abcStock = new Stock();

      BuyStock buyStockOrder = new BuyStock(abcStock);
      SellStock sellStockOrder = new SellStock(abcStock);

      Broker broker = new Broker();
      broker.takeOrder(buyStockOrder);
      broker.takeOrder(sellStockOrder);

      broker.placeOrders();
   }
}
</code>
  - Step 6: Verify the output<code>
Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold
</code>
===== Behavior Pattern: Template Pattern =====
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
==== Design ====
{{:other:template_pattern_uml_diagram.jpg|}}\\
{{:other:patterntemplate.png|}}\\
==== Implementation ====
  - Step 1: Create an abstract class with a template method being final Game.java<code java>
public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();

   //template method
   public final void play(){

      //initialize the game
      initialize();

      //start game
      startPlay();

      //end game
      endPlay();
   }
}
</code>
  - Step 2: Create concrete classes extending the above class
    * Cricket.java<code java>
public class Cricket extends Game {

   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}
    * Football.java<code java>
public class Football extends Game {

   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}
</code>
  - Step 3: Use the Game's template method play() to demonstrate a defined way of playing game TemplatePatternDemo.java<code java>
public class TemplatePatternDemo {
   public static void main(String[] args) {

      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();		
   }
}
</code>
  - Step 4: Verify the output<code>
Cricket Game Initialized! Start playing.
Cricket Game Started. Enjoy the game!
Cricket Game Finished!

Football Game Initialized! Start playing.
Football Game Started. Enjoy the game!
Football Game Finished!
</code>