Visitor Pattern

Definition -

    Allows one or more operations to be applied at run time allowing the operations to be decided at runtime rather than compile time.


Scenario -
   
    Let us take the same example of a car customization plant where you can customize the windshield color, wheel, color, stripes.
1) We will have an interface called customizable which will be implemented by the components which can be customized based on the users wish else it will use the default. The following things can be customized - windshield color, stripes, wheel.

package VisitorPattern;

public interface customizable {
    
    public void addtocar(customizer c);

}

2) We will have concrete classes for the same windshieldcolor, stripes, wheel.
windshield.java

package VisitorPattern;

public class windowshield implements customizable{
    
    String color;
    
    public windowshield(String color) {
        this.color=color;
    }

    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }
    

}

stripes.java

package VisitorPattern;

public class stripes implements customizable{
    
    String stripestyle;
    
    public stripes(String stripestyle) {
        this.stripestyle=stripestyle;
    }

    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }
    
    

}

wheel.java

package VisitorPattern;

public class wheel implements customizable {

    String style;
    
    public wheel(String style) {
        this.style=style;
    }
    
    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }

}

3) We will have a component called customizer which will be an interface and will have the call to all the customizable components. The interface will enable us to extend in future and be used as a standard across different types of vehicles in future.

package VisitorPattern;

public interface customizer {
    
    public void addcomponent(windowshield w);
    public void addcomponent(wheel wl);
    public void addcomponent(stripes s);

}

4) We will have implementer which is a concrete implementation of the customizer.

package VisitorPattern;

public class customizerimpl implements customizer {
    
    

    @Override
    public void addcomponent(windowshield w) {
        
        System.out.println("Adding windshield of color: "+w.color);
        
    }

    @Override
    public void addcomponent(wheel wl) {
        
        System.out.println("Adding wheel of style: "+wl.style);
        
    }

    @Override
    public void addcomponent(stripes s) {
        
        System.out.println("Adding stripes of style: "+s.stripestyle);
        
    }

}

To see this pattern in action use the code below - 

package VisitorPattern;

import java.util.ArrayList;

public class visitordemo {

    public static void main(String[] args) {
        
        ArrayList<customizable> customcomp=new ArrayList<customizable>();
        customcomp.add(new windowshield("Blue"));
        customcomp.add(new wheel("Yokohama Pro ++"));
        customcomp.add(new stripes("Stripe1"));
        
        customizer creator=new customizerimpl();
        
        for(customizable tempc: customcomp) {
            tempc.addtocar(creator);
        }

    }

}

Place to use -
1) When you want to call different functionalities based on user input and it might be unrelated objects which might be passed based on scenario.

The code for the above is present in the link

Template Pattern

Definition -

    As the name states, this pattern will provide a template of steps to be followed inorder to complete a task or part of a task.

There will be an interface or an abstract class which will be used by concrete classes and implement or extend all the steps.
Scenario -
   
    Let us take the same example of a car manufacturing plant where in the plant manufactures a car or sedan. The process to build either car is the same hence -
1) We will have an abstract class called buildcar with the following functions - getchassis, addwheel, addengine, addseats. 

package TemplatePattern;

public abstract class buildcar {
    
    public abstract void getchassis();
    public abstract void addengine();
    public abstract void addwheels();
    
    public final void build() {
        getchassis();
        addengine();
        addwheels();
        System.out.println("Completed building");
    }

}

2) We will have two concrete classes called hatchback and sedan.
hatchback.java
 

package TemplatePattern;

public class hatchback extends buildcar {

    @Override
    public void getchassis() {
        
        System.out.println("Getting chassis for a hatchback");
        
    }

    @Override
    public void addengine() {
        
        System.out.println("Adding engine to hatchback");
        
    }

    @Override
    public void addwheels() {
        
        System.out.println("Adding wheels to hatchback");
        
    }

}

sedan.java
 

package TemplatePattern;

public class sedan extends buildcar {

    @Override
    public void getchassis() {
        
        System.out.println("Getting chassis for a sedan");
        
    }

    @Override
    public void addengine() {
        
        System.out.println("Adding engine to sedan");
        
    }

    @Override
    public void addwheels() {

        System.out.println("Adding wheels to sedan");
        
    }

}

3) The below code shows the demo for the same

package TemplatePattern;

public class templatedemo {

    public static void main(String[] args) {
        
        buildcar bc=new hatchback();
        bc.build();
        

    }

}

Place to use -
1) When have a scenario which can be made into templates.
2) You want to control what happens at each step and avoid rewriting the code in multiple places.

The code used above is present in the link

Strategy Pattern

Definition -

    This is a pattern where in the client can choose among the options available to perform a specific task.
   
Scenario -
   
    Lets take a scenario where in you want the user to login via either forms authentication or google or facebook id. In this case you can apply the strategy pattern where in the same task of authentication is done but the method by which the authentication is done is different.
   
Based on the above -
1) We will have an interface called iauthenticate with a function called authenticateuser.

package StrategyPattern;

public interface iauthenticate {
    
    
    public boolean authenticateuser();

}

2) We will have two concrete classes called formsauthentication and googleauthentication.
formsauthentication.java
 

package StrategyPattern;

public class formsauth implements iauthenticate{

    String user;
    String password;
    
    public formsauth(String usr, String pwd) {
        this.user=usr;
        this.password=pwd;
    }
    
    @Override
    public boolean authenticateuser() {
        String pwd=getauthdetails(this.user);
        if(pwd==this.password) {
            return true;
        }
        else {
            return false;
        }
        
    }

    
    public String getauthdetails(String user) {
        
        return "*******";
        
    }

}

googleauthentication.java

package StrategyPattern;

public class googleauthentication implements iauthenticate {

    
    String user;
    String token;
    
    public googleauthentication(String usr,String tkn) {
        this.user=usr;
        this.token=tkn;
    }
    
    public String getauthdetails(String user) {
        //get the token from google
        return "axr4550313djrldoepcvjrmvrortjvlr";
    }

    @Override
    public boolean authenticateuser() {
        String temptkn=getauthdetails(this.user);
        if(this.token==temptkn) {
            return true;
        }
        return false;
    }

}

3) We will have a class called strategydemo which will have the option chosen by the user to authenticate and gain access into the system.
 

package StrategyPattern;

public class Strategydemo {
    
    public static void main(String args[]) {
        
        iauthenticate ia=null;
        String authtype="forms";
        
        if(authtype.equalsIgnoreCase("forms")) {
            ia=new formsauth("user1","*******");
        }else if(authtype.equalsIgnoreCase("Google")) {
            ia=new googleauthentication("user1","axr4550313djrldoepcvjrmvrortjvlr");
        }
        
        if(ia.authenticateuser()) {
            System.out.println("Authentication successful");
        }
        
    }

}

Place to use -
1) When you want to choose a technique to perform a functionality but you want to provide flexibility in terms how this can be achieved.

The code used above is present in the link here

State Pattern

Definition -

    This is a pattern where in the object changes its behavior based on the state.
   
Scenario -
Let us consider a scenario where in the windshield of your car has to start the wiper if the rain starts or it needs to enable polarized light depending on the intensity of light.

Based on the above -
1) A interface called eventstate which will have a method called performaction.

package StatePattern;

public interface eventstate {
    
    public void performaction();

}

2) A class rain which will implement the eventstate.

package StatePattern;

public class rain implements eventstate {

    @Override
    public void performaction() {
        
        System.out.println("Wiper will be turned on");
        
    }

}

3) A class day which will implement the eventstate.

package StatePattern;

public class day implements eventstate {

    @Override
    public void performaction() {
        
        System.out.println("Wiper will be turned on");
        
    }

}

4) A windshieldcontext which will perform action based on state.

package StatePattern;

public class windshieldcontext implements eventstate {
    
    eventstate es;
    
    public void setcontext(eventstate e) {
        this.es=e;
    }

    @Override
    public void performaction() {
        
        this.es.performaction();
        
    }

}

5) The client code for the same is given below

package StatePattern;

public class statedemo {
    
    public static void main(String args[]) {
        eventstate es;
        windshieldcontext ws=new windshieldcontext();
        String states="Rain";
        if(states.equalsIgnoreCase("Rain")) {
            es=new rain();
            ws.setcontext(es);
        }
        else if(states.equalsIgnoreCase("Day")) {
            es=new day();
            ws.setcontext(es);
        }
        
        ws.performaction();
        
    }

}

Place to use -
1) When you have want the object to behave different in different scenarios and at the sametime decouple the systems so that the conditions are decided only in run time and not in compile time.

The code for the above is present in the link here

Observer Pattern

Definition -

    It provides a proxy implementation for another object and controls access to the real object.

These are patterns which you would be using unknowingly (if you are new to design patterns) in the click event listener or the event listeners.
Scenario -

1) Let us have a class called obsrvvalue which will have a variable whose value is being observed. This is called observable.

package ObserverPattern;

import java.util.Observable;

public class obsrvvalue extends Observable {
    
    private int val=0;
    
    public obsrvvalue(int newval) {
        this.val=newval;
    }
    
    public void setnewval(int newval) {
        this.val=newval;
        setChanged();
        notifyObservers();
    }
    
    

}

2) Let us have a class called observerobject which will observe the observable object and check if the value is same or not and report.

package ObserverPattern;

import java.util.Observable;
import java.util.Observer;

public class observerobject implements Observer{
    
    
    private obsrvvalue obs=null;
    
    public observerobject(obsrvvalue o) {
        this.obs=o;
    }

    @Override
    public void update(Observable arg0, Object arg1) {
        if(arg0==arg1) {
            System.out.println("Both are equal");
        }
        else {
            System.out.println("The value is updated");
        }
        
    }

}

3) To see the pattern in demo use the code below

package ObserverPattern;

public class observerdemo {
    
    public static void main(String args[]) {
        
        obsrvvalue o=new obsrvvalue(10);
        observerobject oo= new observerobject(o);
        o.addObserver(oo);
        o.setnewval(10);
    }

}

Place to use -
1) When you have listener waiting to act if the object changes.

The code for the above is present in the link here

Memento Pattern

Definition -

    This pattern provides ability to make efficient use of resources when there are too many objects created by reusing some or all of them.
   
Scenario -

    The most common example and the best suited that example you will see for this is a file editor where in the file gets saved after sometime and if the system shuts down unexpectedly on restart the system will give you an option to recover a saved state. This is one of the best example you can get for this.
Based on the above -
1) There will be a class filesavedstate which will server memory of the previously automated saved state.

package Memento;

public class filesavedstate {
    private String data;
    
    public filesavedstate(String state) {
        this.data=state;
    }
    
    public String getdata() {
        return this.data;
    }

}

2) There will be a class called file which will be modified by a program and saves its state into the filesavedstate class and obtains it if necessary.

package Memento;

public class file {
    
    public String filedata;
    filesavedstate fs;
    public file(String content) {
        this.filedata=content;
    }
    
    public void savestate() {
        fs=new filesavedstate(this.filedata);
    }
    
    public void getsaveddata() {
        String saveddata=fs.getdata();
        System.out.println("The saved data is :"+saveddata);
    }
    

    public static void main(String[] args) {
        
        file f=new file("Trying to show a demo");
        f.savestate();
        f.getsaveddata();
    }

}

Place to use -
1) When you want to save a state of the object and use it for later.
2) Useful in editors.

The code for the above can be found in the link here

Mediator Pattern

Definition -

    This provides the ability to have effective communication between two modules or objects within the same module. This provides centralized control over the system.

Scenario -

    Let us take an example of an object wanting to write into a filesystem. In this case we will have a mediator to which all the objects will communicate and write into the file.
Based on the above scenario -
1) filemediatorinterface class who provides the implmentation guidelines 

package MediatorPattern;

public interface ifilemediator {
    
    public void addrequest(filemod f);
    
    public void addfile(File f);
    
    public void givecontrol(File f, filemod fm);
    

}

2) A filemod class which wants to modify a file.

package MediatorPattern;

public class filemod {
    
    String modname;
    File filename;
    
    public filemod(String name, File file) {
        this.modname=name;
        this.filename=file;
    }
    
    public void modifyfile(File f) {
        System.out.println("Modifying file : "+f.filename);
    }

}

3) A File class which is the one to be modified.

package MediatorPattern;

public class File {
    
    public String filename;
    
    public File(String name) {
        this.filename=name;
    }
    

}

4) A filemediator which controls which object gets to perform action.

package MediatorPattern;

import java.util.ArrayList;

public class filemediatorImpl implements ifilemediator{
    
    ArrayList<filemod> fm=new ArrayList<filemod>();
    
    ArrayList<File> f=new ArrayList<File>();
    

    @Override
    public void addrequest(filemod f) {
        
        System.out.println("Adding request :"+f.modname+ " into the queue");
        fm.add(f);
        
    }

    @Override
    public void givecontrol(File f, filemod fm) {
        
        System.out.println("Giving control to filemod "+fm.modname+" over the file "+f.filename);
        fm.modifyfile(f);
        
    }

    @Override
    public void addfile(File f) {
        
        System.out.println("Fetching file "+f.filename+ " for modification");
        
    }

}

Place to use -
1) When you have too many objects from a system speaking too many objects of other system.
2) You have very structured communication channel

The code for the above is present in the link here

Interpreter Pattern

Definition -

    The use of an interpreter that used to interpret the requests from the client through the use of representations.

Scenario -

    Let us take an example of currency conversion where in a client wants to convert money from USD to either INR or Euros. The system uses the conversion factor to calculate the amount and send it back to the client.
   
   
Based on the above scenario -
1) An interpreter called currencyconverter.

package InterpretorPattern;

public class currencyconvertor {
    
    double cusdtoinr=60.0;
    double cusdtoeur=1.3;
    
    public double getusdtoinr(double sourceamount) {
        return sourceamount*cusdtoinr;
    }
    
    public double getusdtoeur(double sourceamount) {
        return sourceamount * cusdtoeur;
    }

}

2) A class which will have the actual interpretation called convertor.

<pre style="font-family: Andale Mono, Lucida Console, Monaco, fixed, monospace; color: #000000; background-color: #eee;font-size: 12px;border: 1px dashed #999999;line-height: 14px;padding: 5px; overflow: auto; width: 100%"><code>package InterpretorPattern;

public interface convertor {
    
    double convert(currencyconvertor cc);

}

</code></pre>

3) A class called USDtoINR and another called USDtoEur

usdtoeurjava

package InterpretorPattern;

public class usdtoeur implements convertor {
    
    private double amt;
    
    public usdtoeur(double curr) {
        this.amt=curr;
    }

    @Override
    public double convert(currencyconvertor cc) {
        return cc.getusdtoeur(amt);
    }

}

usdtoinr.java
 

package InterpretorPattern;

public class usdtoinr implements convertor{

    private double amt;
    
    public usdtoinr(double curr) {
        this.amt=curr;
    }
    
    @Override
    public double convert(currencyconvertor cc) {
        return cc.getusdtoinr(amt);
    }

}

4) A client which will use the interpreter to covert the value.

package InterpretorPattern;

public class interpretordemo {
    
    
    
    
    public static void main(String args[]) {
        
        System.out.println("Converting $100 to EUR");
        double amt=100;
        double convertedamt=0;
        currencyconvertor cc=new currencyconvertor();    
        String converttocurr="EUR";
        
        convertor c=null;
        
        if(converttocurr.equalsIgnoreCase("INR")) {
            
            c=new usdtoinr(amt);
            convertedamt=c.convert(cc);
            System.out.println("The converted amount in INR is: "+convertedamt);
            
        } else {
            
            c=new usdtoeur(amt);
            convertedamt=c.convert(cc);
            System.out.println("The converted amount in EUR is: "+convertedamt);
            
        }
        
        
    }
    
    
    
    

}

Place to use -
1) It can be used in places where you want one format to be converted into another format.
2) It can be used in places where you are checking for grammar or evaluating an expression written on an UI.


To be careful about -
1) Performance of the code can be an issue, so you need to use this pattern very carefully.

The link for the code is present in the link here

Command Pattern

Definition -
    It provides a generic interface to all the classes which implement it to execute certain commands. This can be treated like the director in the builder pattern.


Scenario -

    Let us take an example of the production line itself, where the client places an order for a vehicle and depending on the order a hatchback or a sedan car is created.
In this case -
1. The interface called order which have an execute funtion to process the request of the client. Note, we can name the function with any name, for the sake of understanding it has named as execute.
 

package CommandPattern;

public interface order {
    
    public void execute();

}

2. hatchback is a class which will implement order and create a hatchback.
 

package CommandPattern;

public class hatchback implements order {

    @Override
    public void execute() {
        
        System.out.println("Creating a hatchback");
        
    }

}

3. sedan is a class which will implement order and create a sedan.

package CommandPattern;

public class sedan implements order {

    @Override
    public void execute() {
        
        System.out.println("Creating a sedan");
        
    }

}

4. A class called router which will hold the order object and invokes the method.

package CommandPattern;

public class router {
    
    String typeofcar=null;
    order o=null;
    
    
    
    public void createcar(String type) {
        if(type.equalsIgnoreCase("Hatchback")) {
            o=new hatchback();
        }else if(type.equalsIgnoreCase("Sedan")) {
            o=new sedan();
        }
        
        o.execute();
    }
    
}

5. Client class which will order for a hatchback or a sedan.
   

package CommandPattern;

public class commandpattern {
    
    public static void main(String args[]) {
        
        router r=new router();
        r.createcar("Hatchback");
        r.createcar("Sedan");
        
        
    }

}

Place to use -
1) When you want the client and the implmentor to be independent of each other.
2) When the request processor need not be known to the client during compile time.
3) One interface to do varying operations based on varying commands at varying time.

Place not to use -
1) Can create maintainence nightmare because if the system has lot of commands then it can cause confusions.
2) If the command parameters vary in future then it can cause change in the entire implementation.
The link for the code above is in the link here

Chain of Responsibility Pattern

Definition -
    This is a pattern where in there are a series of handlers which cater to a specific part or order of the request. In this pattern the client will not know who is addressing the request. The handlers decide among themselves who will server a particular request.
    This can also result in none of the handlers serving the request.


Scenario -
Lets take an example of a warehouse machine whose job is sort the incoming materials based on the type. For simplicity lets take there are two types of containers with tags of solid and liquid.
In this we will have a
1. The object here is a package so we will declare a class called pckg. 

 

package ChainofCommandPattern;

public class pckg {
    
    String type;
    
    public pckg(String objtype) {
        this.type=objtype;
    }
    
    public String gettype() {
        return this.type;
    }

}

2. A packagehandler which will have the functions that needs to be implemented. 
 

package ChainofCommandPattern;

public interface packagehandler {
    
    void setnext(packagehandler ph);
    void handlerequest(pckg pkg);

}

3. A solidpackagehandler and liquidpackagehandler which will have respective functions to handle the package.
solidpackagehandler.java
 

package ChainofCommandPattern;

public class solidpackagehandler implements packagehandler {

    packagehandler next;
    
    @Override
    public void setnext(packagehandler ph) {
        
        next=ph;
        
    }

    @Override
    public void handlerequest(pckg pkg) {
        
        if(pkg.type.equalsIgnoreCase("Solid")) {
            
            System.out.println("Handled the Solid object");
            
        } else if(pkg.type.equalsIgnoreCase("Liquid")) {
            next.handlerequest(pkg);
        }
        
    }

}

liquidpackagehandler.java

package ChainofCommandPattern;

public class liquidpackagehandler implements packagehandler{
    
    packagehandler next;

    @Override
    public void setnext(packagehandler ph) {
        
        next=ph;
        
    }

    @Override
    public void handlerequest(pckg pkg) {
        
        if(pkg.type.equalsIgnoreCase("Liquid")) {
            
            System.out.println("Handled the Liquid object");
            
        } else if(pkg.type.equalsIgnoreCase("Solid")) {
            next.handlerequest(pkg);
        }
        
    }
    
    

}

4. Finally a client which will use the above classes.

package ChainofCommandPattern;

public class chainofcommandclient {
    
    public static void main(String args[]) {
        
        packagehandler pckg1=new solidpackagehandler();
        packagehandler pckg2=new liquidpackagehandler();
        
        pckg1.setnext(pckg2);
        
        pckg1.handlerequest(new pckg("Solid"));
        pckg2.handlerequest(new pckg("Liquid"));
        
    }

}

   

Place to use -
1. When you have multiple handlers which can process the same request.
2. A request not being handled by any handler is an accepted scenario.



Place not to use -
1. Can be slower since it has to follow a specified path.
2. A request might not be addressed by the system implementing this pattern.
3. It can be difficult to maintain if the system has too many handlers and complex routes.