Showing posts with label design pattern. Show all posts
Showing posts with label design pattern. Show all posts

Wednesday, December 4

Iterator Design Pattern

Iterator design pattern in java

Lets write an class that has method next() and hasNext() which basically are backbone for iterator design pattern

This Iterator will be iterating over a collection represented by Collection class

Collection class consist of an array of elements that Iterator will be iterating over.

Additionally methods to add and remove elements from array are also available in Collection class

IteratorTestor class consist of all the scenarios where in




  1. First we are iterating over existing list of elements
  2. Then few elements are added to the array and It is again iterated over
  3. Then few elements are removed from the array and then It is again iterated over

Here is the Well compiled code to try this via java code

-=========================================================


public interface Iterator {
   
    public Object next();
    public boolean hasNext();

}


=========================================================


public interface Container {
   
    public Iterator getIterator();

}

=======================================================

This class consist of an inner class MyIterator which basically becomes the part of collection class and
thus it becomes easy for MyIterator class to work on variables of enclosing class. 


import java.lang.reflect.Array;

public class Collection implements Container {

    public
    String[] list = {"element1", "element2", "element3", "element4" };

    public int index;

    @Override
    public Iterator getIterator() {
        // TODO Auto-generated method stub
        return new MyIterator();
    }
   
    public void addElement(Object obj){
        int arrLength=list.length;
        arrLength++;
        String[] newArr =new String[arrLength];
        newArr[arrLength-1]=obj.toString();
        System.arraycopy(list, 0, newArr, 0, list.length);
        list=new String[newArr.length];
        System.arraycopy(newArr, 0, list, 0, newArr.length);


    }
   
    public void removeElement(Object obj){
        int arrLength=list.length;
        arrLength--;
        String[] newArr =new String[arrLength];
        System.arraycopy(list, 0, newArr, 0, list.length-1);
        list=new String[newArr.length];
        System.arraycopy(newArr, 0, list, 0, newArr.length);


    }


    private class MyIterator implements Iterator {

        @Override
        public Object next() {
            // TODO Auto-generated method stub
            if (hasNext()) {
                return list[index++];
            }
            return null;
        }

        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            if (list.length > index) {
                return true;
            }
            return false;
        }

    }

}

============================================================








public class IteratorTester {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection repo = new Collection();

        while (repo.getIterator().hasNext()) {
            System.out.println(repo.getIterator().next());
        }

        System.out.println("=================Lets Add Few More Elements========================");

        repo.index=0;
        repo.addElement("NewElemen1");
        repo.addElement("NewElemen2");
        repo.addElement("NewElemen3");
        while (repo.getIterator().hasNext()) {
            System.out.println(repo.getIterator().next());

        }
        System.out.println("===============Lets Remove few elements==========================");

        repo.index=0;
        repo.removeElement("Elemen1");
        repo.removeElement("Elemen2");
        while (repo.getIterator().hasNext()) {
            System.out.println(repo.getIterator().next());

        }


    }
}
===================================================






And this program will print below logs on console :


++++++++++++++++++++++++++++++++++++++++

element1
element2
element3
element4
=================Lets Add Few More Elements========================
element1
element2
element3
element4
NewElemen1
NewElemen2
NewElemen3
===============Lets Remove few elements==========================
element1
element2
element3
element4
NewElemen1

+++++++++++++++++++++++++++++++++++++++

Monday, December 2

Command Design Pattern

Consider yourself a referee of a race where you need to give below commands to athletes

Ready -- Athlete to get ready for race
Set  ---
Athletes to all set to run
Go  ---
Athletes to run the race

How can we automate this in java using command design pattern .





Lets consider there is a Race class which defines there action


public class Race {

    public void getReady() {

        System.out.println("getting ready");
    }

    public void set() {
        System.out.println("setting running position");

    }

    public void go() {
        System.out.println("running");

    }
}



Now we need to create there command classes for these three actions

Let's create an interface first which basically will be uniformly implemented by all there command classes

Interface name is Position. It is declaring single method execute()


public interface Position {

    public void execute();
}







Next there command classes

Ready , Set and Go


public class Ready implements Position {

    Race race;   
    public Ready(Race race){
        this.race=race;
    }
    @Override
    public void execute() {

        race.getReady();

    }
}



public class Set implements Position {

    Race race;   
    public Set(Race race){
        this.race=race;
    }
   
    @Override
    public void execute() {
        race.set();
    }

}


public class Go implements Position {

    Race race;   
    public Go(Race race){
        this.race=race;
    }
   
    @Override
    public void execute() {
        race.go();

    }

}



-->


Every command class has one argument constructor which allows Command instances set Race class instance to execute the method on Race class.

Now it is duty of Referee to pass instance of Race class to Commands and Commands will execute() the method invoked inside execute() method.

Here is Referee class


public class Referee {

    public static void main(String args[]){
        Race race=new Race();
       
        Position position1=new Ready(race);
        Position position2=new Set(race);
        Position position3=new Go(race);
       
        position1.execute();
        position2.execute();
        position3.execute();

       
        }

}


Put together all these classes and execute program as java application. That will print below logs on console :



getting ready
setting running position
running



Sunday, December 1

Memento Design Pattern

This pattern talks about restoring the original state at any point of time . For example

I start with knowing the mileage of bike around reference value 80KM/h

I store this value in an string instance say : mileage

My reference value / Original value is 80KM/h

Now I start knowing mileage of various bikes and keep updating the the latest known mileage in same string instace :  mileage

current value might change from 80 to 70 to 50 to 40 to 100 and so on  depending upon the mileage of bikes.

So at any point of time If i want to know the reference value , It's no more there is mileage string.

So how do I make sure that I keep on working on current value as well as be able to retrieve the original value at any point of time.

There might be many ways you ca think across , Memento design pattern suggest a standard way to do that.

Pattern revolves around two contributors

Originator
Care Taker

Originator stores the original value in a non-modified way.
Care Taker takes care of returing current or original value at any point of time
Client directly interacts with Care taker to get current or original value


Now lets see how simple is it to implement it in java :


Originator class stores the original value and it can't be modified .







public class Originator {

    private final String mileage ="80";
   
    public String getFinalInstance(){
        return mileage;
    }

}
CareTaker provides method to get to current or original mileage at any point of time


public class CareTaker {

    private String mileage;
    public CareTaker(String instance) {
       this.mileage=instance;
    }

   public String saveCurrentInstance(String instance){
       this.mileage=instance;
       return this.mileage;
   }
  
   public String restoreDefaultInstance(){
       Originator finalInstance=new Originator();
      return  finalInstance.getFinalInstance();
}
   public String getCurrentValue(){
       return  mileage;
   }
}



-->


And here is our Client who interacts with CareTaker to play with current value and reach original value at any point of time.


public class MementoClient {

    public MementoClient() {
        // TODO Auto-generated constructor stub
    }
   
    public static void main(String args[]){
       
       System.out.println("Some original reference value is already set .......");
        CareTaker instance =new CareTaker("50");
        System.out.println("Let us create an instance with current value ::: 50");
        System.out.println("Lets find out the  original reference  value ");
       System.out.println("it is :::" + instance.restoreDefaultInstance());
        System.out.println("and the current value is :: ");
       System.out.println(instance.getCurrentValue());
        System.out.println("Lets change the value to 40");
        instance.saveCurrentInstance("40");
        System.out.println("Now current value is :::  " + instance.getCurrentValue());
        System.out.println("Let's again change the value to :::100");
        instance.saveCurrentInstance("100");
        System.out.println("Now current value is : " + instance.getCurrentValue());
        System.out.println("Now I want to get to the original  value");
        System.out.println("it is ::: " + instance.restoreDefaultInstance());

    }

}







Executing this application as java application will print below logs on console :

===============================
Some original reference value is already set .......
Let us create an instance with current value ::: 50
Lets find out the  original reference  value
it is :::80
and the current value is ::
50
Lets change the value to 40
Now current value is :::  40
Let's again change the value to :::100
Now current value is : 100
Now I want to get to the original  value
it is ::: 80

================================


 

Friday, November 29

Observer design pattern in java

Lets talk about observer design pattern today--

Lets take in consideration a real time scenarion 

There is a News Control Center that controls current news and subscribers . 

Lets say there are two subscribers Ching and Chong

Ching and Chong are registered by News Control center for current news 

If at any point of time current news are updated News needs to be informed to its all subscribers. 

Subscriber will not keep on checking news all the time If any current news is updated. They will register once for all and News

will ensure that they are timely informed about every new news. So how will that hapend





Ching and Chong will act as observers / listener . News will see If any new news is updated it is informed to its subscribers 


Below Code details this and implement the scenario in java code .

NewsControlCenter Class will hold the main control to apply for subscriber registeration and bring in new news to the agency


==================



public class NewsControlCenter {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Subscriber sub1=new Subscriber("ching");
        Subscriber sub2=new Subscriber("chong");
        News news=new TimesNews();
        news.registerSubscriber(sub1);
        news.registerSubscriber(sub2);
        
        System.out.println("==========news changed======");

        news.updateNews("Narayan traced");
        
        System.out.println("==========news changed again ======");

        news.updateNews("Govt declared prize money on informing Narayan's whereabout.");

        
       
    }

}

==================


import java.util.List;

public interface News {
    void registerSubscriber(Subscriber sub);

    void unRegisterSubscriber(Subscriber sub);

    void updateNews(String news);
    void inform(Subscriber sub);
    void inform(List subs);
    void readCurrentNews();
}


==================








import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TimesNews implements News {

    String currentNews = "Asharam in Jail";

    List subscribers = new ArrayList();

    @Override
    public void registerSubscriber(Subscriber sub) {
        subscribers.add(sub);
    }

    @Override
    public void unRegisterSubscriber(Subscriber sub) {
        subscribers.remove(sub);
    }

    @Override
    public void updateNews(String news) {

        this.currentNews = news;
        inform(subscribers);

    }

    public void inform(Subscriber sub) {

    }

    public void inform(List subs) {

        for (Iterator iterator = subs.iterator(); iterator.hasNext();) {
            Subscriber subscriber = (Subscriber) iterator.next();
            inform(subscriber);
        }

    }

    public void readCurrentNews() {
        System.out.println(this.currentNews);
    }

}


=====================


-->


public class Subscriber {

    String name;

    public Subscriber(String name) {
        this.name = name;
    }

    public void readNews(News news) {

        System.out.println("Mr. " +name+ ": got this news:::");
        news.readCurrentNews();
}
}


=================



On executing this program as java application . Below logs will be written on console


----------------------------------------------------------

opening news for ::: ching
Asharam in Jail
opening news for ::: chong
Asharam in Jail
==========news changed======
Mr. ching: got this news:::
Narayan traced
Mr. chong: got this news:::
Narayan traced
==========news changed again ======
Mr. ching: got this news:::
Govt declared prize money on informing Narayan's whereabout.
Mr. chong: got this news:::
Govt declared prize money on informing Narayan's whereabout.

-------------------------------------------------------------------------------------

Wednesday, November 20

Once again on visitor's design pattern

I have two employees in my organization : Manoj and Kumar

I wish to have Manoj's employee  data in text format and Kumar's employee data in HTML format

What I would do to get it done :

1. I will create Employee instance called Manoj
2. I will ask Manoj to accept Textformatter as it's formatter
3. Once Manoj accept it , it will ask it's Formatter to apply text formatter on it's data

Code for this is as below :

------------------------------------------

package com;

public class Employee {

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    String name;

    public Employee() {
        // TODO Auto-generated constructor stub
    }

    public void accept(Formatter visitor) {

        visitor.visit(this);
    }

}
--------------------------------------------







package com;

public interface Formatter {
    
   void visit(Employee emp);
    
   String getResult();
}

------------------------------------------

package com;


public class TextFormat implements Formatter {
    
    String formatting;

    public TextFormat() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public void visit(Employee emp) {
        
        formatting= "formatted the "+ emp.getName()+ " employee data in text format";
    }

    public String getResult(){
        
        return formatting;
    }

}

--------------------------------------------








package com;

public class Test {

    public Test() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     */
    public static void main(String[] args) {

        Employee emp =new Employee();
        
        Formatter visitor =new TextFormat();
        
        emp.setName("Manoj");
        emp.accept(visitor);
        
        System.out.println(visitor.getResult());
        
    
        
    }

}

----------------------------------------------


Similarly for Kumar to have it's data formatted in HTML format 

1. I will create Employee instance called Kumar
2. I will ask Kumar to accept HTMLformatter as it's formatter
3. Once KUMAR accept it , it will ask it's Formatter to apply HTML formatter on it's data 


Code for this is : 



---------------------------------------






package com;

public class HTMLFormat implements Formatter {

    String formatting;
    
    public HTMLFormat() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public void visit(Employee emp) {
        formatting= "formatted the "+ emp.getName()+ " empolyee data in HTML format";
    }
    
    public String getResult(){
        return formatting;
    }

}

-----------------------------------

package com;

public class Test {

    public Test() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     */
    public static void main(String[] args) {

        Employee emp =new Employee();
        
        Formatter visitor =new TextFormat();
        
     
        
        visitor =new HTMLFormat();
        emp.setName("Kumar");

        emp.accept(visitor);
        
       System.out.println(visitor.getResult());
        
    }

}


-----------------------------------------



Test class to collectively apply formatters on Manoj and Kumar below Code could be used in single Test class:


----------------------------------------

package com;

public class Test {

    public Test() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     */
    public static void main(String[] args) {

        Employee emp =new Employee();
        
        Formatter visitor =new TextFormat();
        
        emp.setName("Manoj");
        emp.accept(visitor);
        
        System.out.println(visitor.getResult());
        
        visitor =new HTMLFormat();
        emp.setName("Kumar");

        emp.accept(visitor);
        
       System.out.println(visitor.getResult());
        
    }

}

-------------------------------

Sunday, October 6

Builder Design Pattern

What is builder design pattern ?

This is used to segregate the logic for creation of complex objects. 

For example

 If we want to create an object of class representing real Estate residential project . We need to take into account lot of factors in building full fledged object . Object will consist of features like 
 payment plan 
layout 
construction plan 
builder information 
land details 
finance details 
location details
salient features 

and so on.....




So we won't prefer to embed the logic of creation of this instance in actual business logic and unnecessarily clutter the business logic flow Instead It would be good to have a dedicated service which can build up this object and once prepared can return it to business logic . Thus actual business logic remains agnostic of all object creation complexities..

So how do we achieve that in Object oriented language . 


Let us try to understand this with code. As usual I have written lot of System.out.println statements in the code to bring are execution flow steps in print statements . This code can be directly copied and executed .All steps of design pattern will be clearly written on console.


-----------------------------------------------------------------------------------------------

//This is the Client class which basically place an order. Here this client first place an order of //commercial project and after it's successful delivery It approaches for residential project and //place an order for that.



package realEstate;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
      
        projectOwner owner=new projectOwner(new CommercialProjectBuilder());
        owner.placeRoder();
        owner.getProject();
        System.out.println("CLIENT :::: Thank you for timely delivry of commerical project");
        System.out.println("===============================================================");
        System.out.println("CLIENT :::: Now let's deal in residenrial");
         owner=new projectOwner(new ResidentialProjectBuilder());
        owner.placeRoder();
        owner.getProject();
        System.out.println("CLIENT :::: Thank you for timely delivry of Residential project.. Rocking performance");
    }

}

// This is project Owner . Client passes the type of project It is looking for : commercial or residential //and creates Project Owner instance . Owner will further place order of construction to Commercial //or Residential department based of which object is passed by client 
class projectOwner{
    ProjectBuiding building;
    projectOwner(ProjectBuiding building){
        this.building=building;
        }
   
  void  placeRoder(){
      building.constructBase();
      building.constructFloors();
      building.doFinishing();
      building.decorate();

   }
 
  ProjectBuiding  getProject(){
      return building;
  }
  
   
}

// Interface for Residential and commercial project builder classes 
interface ProjectBuiding{
   
   
   
    void constructBase();
   
    void constructFloors();
   
    void doFinishing();
   
    void decorate();
   
   
}

// entire process and logic of building a residential project is encapsulated in this class
class ResidentialProjectBuilder implements ProjectBuiding {
   
    ResidentialProjectBuilder(){
        System.out.println("ResidentialProjectBuilder:::Thank you for reaching us..We deal in Residential Projects..");
    }

    public void constructBase() {
      
        System.out.println("ResidentialProjectBuilder:::Construction is already started.. Promise to deliver on time ");
    }

    public void constructFloors() {
        System.out.println("ResidentialProjectBuilder::::Construction is on full Swing.. Pay installments timely ");
       
    }

    public void doFinishing() {
        System.out.println("ResidentialProjectBuilder::::About to deliver .. Have litte more Patience ");
       
    }

    public void decorate() {
        System.out.println("ResidentialProjectBuilder:::IT is well decorated.. Ready to move");
       
    }
   
}


// entire process and logic of building a Commercial project is encapsulated in this class


class CommercialProjectBuilder implements ProjectBuiding{

    CommercialProjectBuilder(){
        System.out.println("CommercialProjectBuilder ::: Thank you for reaching us..We deal in Commercial Projects..");
    }
   
    public void constructBase() {
        System.out.println("CommercialProjectBuilder :::Construction is already started.. Promise to deliver on time ..");
       
    }

    public void constructFloors() {
        System.out.println("CommercialProjectBuilder :::Construction is on full Swing.. Pay installments timely ");
       
    }

    public void doFinishing() {
        System.out.println("CommercialProjectBuilder :::About to deliver .. Have litte more Patience ");
       
    }

    public void decorate() {
        System.out.println("CommercialProjectBuilder :::IT is well decorated.. Ready to move");
       
    }
   
}


 Below would be the output of console on program execution
-------------------------------------------------------------------------------------------










CommercialProjectBuilder ::: Thank you for reaching us..We deal in Commercial Projects..
CommercialProjectBuilder :::Construction is already started.. Promise to deliver on time ..
CommercialProjectBuilder :::Construction is on full Swing.. Pay installments timely
CommercialProjectBuilder :::About to deliver .. Have litte more Patience
CommercialProjectBuilder :::IT is well decorated.. Ready to move
CLIENT :::: Thank you for timely delivry of commerical project

===============================================================



CLIENT :::: Now let's deal in residenrial
ResidentialProjectBuilder:::Thank you for reaching us..We deal in Residential Projects..
ResidentialProjectBuilder:::Construction is already started.. Promise to deliver on time
ResidentialProjectBuilder::::Construction is on full Swing.. Pay installments timely
ResidentialProjectBuilder::::About to deliver .. Have litte more Patience
ResidentialProjectBuilder:::IT is well decorated.. Ready to move
CLIENT :::: Thank you for timely delivry of Residential project.. Rocking performance

 


-->