#reading design pattern

[vfvagabond-blog]

DP/14/24/SP: Chain Of Responsibility

Idea is:

Avoiding coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.

The idea of this pattern is to decouple senders and receivers by giving multiple objects a chance to handle a request. The request gets passed along a chain of objects until one of them handles it.

To forward the request along the chain, and to ensure receivers remain implicit, each object on the chain shares a common interface for handling requests and for accessing its successor on the chain.

Extra:

More than one object may handle a request, and the handler isn't known a priori. The handler should be ascertained automatically.

You want to issue a request to one of several objects without specifying the receiver explicitly.

The set of objects that can handle a request should be specified dynamically.

Example:

package com.designpattern.behavioralpattern; /**  *  * @author collection  */ public class ChainfOfResponsibilityPattern {     public static void main(String[] args){         Logger logger, logger1, logger2;         logger = new StdoutLogger(Logger.DEBUG);         logger1 = logger.setNext(new EmailLogger(Logger.NOTICE));         logger2 = logger1.setNext(new StderrLogger(Logger.ERR));                 logger.message("Entering function y.", Logger.DEBUG);         logger.message("Step1 completed", Logger.NOTICE);         logger.message("An error has occurred.", Logger.ERR);             } } abstract class Logger{     public static int ERR = 3;     public static int NOTICE = 5;     public static int DEBUG = 7;     protected int mask;         protected Logger next;     public Logger setNext(Logger log){         next = log;         return log;     }     public void message(String msg, int priority){         if(priority <= mask){             writeMessage(msg);         }         if(next != null){             next.message(msg, priority);         }     }         abstract protected void writeMessage(String msg);    } class StdoutLogger extends Logger{         public StdoutLogger(int mask){         this.mask = mask;     }     @Override     protected void writeMessage(String msg) {         System.out.println("Writing to stdout: " + msg);     }     } class EmailLogger extends Logger{         public EmailLogger(int mask){         this.mask = mask;     }     @Override     protected void writeMessage(String msg) {         System.out.println("Sending via email: " + msg);     }     } class StderrLogger extends Logger{         public StderrLogger(int mask){         this.mask = mask;     }     @Override     protected void writeMessage(String msg) {         System.out.println("Sending to stderr: " + msg);     }     }

[vfvagabond-blog]

DP/12/24/SP: Flyweight pattern

Idea is:

Use sharing to support large numbers of fine-grained objects efficiently.

The intent of this pattern is to use sharing to support a large number of objects that have part of their internal state in common where the other part of state can vary.

A flyweight is a shared object that can be used in multiple contexts simultaneously.

The flyweight acts as an independent object in each context- it's indistinguishable from an instance of the object that's not shared.

A flyweight is an object that minimizes memory use by sharing as much data as possible with other similar objects.

It is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory.

Where it is used:

An application uses a large number of objects.

Storage costs are high because of the sheer quantity of objects

Most object state can be made extrinsic

Many groups of objects may be replaced by relatively few shared objects once extrinsic state is removed.

The application doesn't depend on object identity. Since flyweight objects may be shared, identity tests will return true for conceptually distinct objects.

Example:

package com.designpattern.structuralpattern; import java.util.HashMap; import java.util.Map; /**  *  * @author shaiful islam(palash)  */ public class FlyweightPattern {     private static CoffeeFlavor[] flavors = new CoffeeFlavor[100];     private static CoffeeOrderContext[] tables = new CoffeeOrderContext[100];     private static int ordersMade = 0;     private static CoffeeFlavorFactory flavorFactory;         public static void takeOrders(String flavorIn, int table){         flavors[ordersMade] = flavorFactory.getCoffeeFlavor(flavorIn);         tables[ordersMade++] = new CoffeeOrderContext(table);     }         public static void main(String[] args){         flavorFactory = new CoffeeFlavorFactory();         takeOrders("Cappuccino", 2);         takeOrders("Xpresso", 121);         for (int i = 0; i < ordersMade; i++) {             flavors[i].serveCoffee(tables[i]);         }         System.out.println("total CoffeeFlavor objects made: " +  flavorFactory.getTotalCoffeeFlavorsMade());     }     } //Flyweight factory class CoffeeFlavorFactory{     private Map<String, CoffeeFlavor> flavors = new HashMap<String, CoffeeFlavor>();         public CoffeeFlavor getCoffeeFlavor(String flavorName){         CoffeeFlavor flavor = flavors.get(flavorName);         if(flavor == null){             flavor = new CoffeeFlavor(flavorName);             flavors.put(flavorName, flavor);         }         return flavor;     }         public int getTotalCoffeeFlavorsMade(){         return flavors.size();     } } interface CoffeOrder{     public void serveCoffee(CoffeeOrderContext context); } class CoffeeFlavor implements CoffeOrder{     private String flavor;         public CoffeeFlavor(String newFlavor){         this.flavor = newFlavor;     }         public String getFlavor(){         return this.flavor;     }         @Override     public void serveCoffee(CoffeeOrderContext context) {         System.out.println("Serving coffee flavor " +  flavor + " to table number " + context.getTable());     }     } class CoffeeOrderContext{     private int tableNumber;     public CoffeeOrderContext(int tableNumber){         this.tableNumber = tableNumber;     }     public int getTable(){         return this.tableNumber;     } }

[vfvagabond-blog]

DP/08/24/SP: Bridge pattern

Idea is:

The Bridge Pattern is used to separate out the interface from its implementation.

Doing this gives the flexibility so that both can vary independently.

Also known as Handle/Body

From GOF: Decouple an abstraction from its implementation so that the two can vary independently.

The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.

Bridge design pattern is a modified version of the notion of "prefer composition over inheritance"

UML:

Image description:

Abstraction: defines the abstract interface. maintains the Implementor reference.

RefinedAbstraction: extends the interface defined by Abstraction

Implementor: defines the interface for implementation classes

ConcreteImplementor: implements the Implementor interface

/*  * To change this template, choose Tools | Templates  * and open the template in the editor.  */ package com.designpattern.structuralpattern; /**  *  * @author palash  */ public class BridgePattern {     public static void main(String[] args){         // first example         Fan fan = new Fan();         fan.switchOn();         Bulb bulb = new Bulb();         bulb.switchOff();                 // second example         Shape[] shapes = new Shape[]{             new CircleShape(1, 2, 3, new DrawingAPI1()),             new CircleShape(5, 7, 11, new DrawingAPI2()),         };         for(Shape shape : shapes){             shape.resizeByPercentage(2.5);             shape.draw();         }     } } // first example interface Switch{     public void switchOn();     public void switchOff(); } class Fan implements Switch{     @Override     public void switchOn() {         System.out.println("Fan's switch on");     }     @Override     public void switchOff() {         System.out.println("Fan's switch off");     }   } class Bulb implements Switch{     @Override     public void switchOn() {         System.out.println("Bulb's switch on");     }     @Override     public void switchOff() {         System.out.println("Bulb's switch off");     }     } /////////////////////////////////////// // second example //implementor interface DrawingAPI{     public void drawCircle(double x, double y, double radius); } // concreteImplementor class DrawingAPI1 implements DrawingAPI{     @Override     public void drawCircle(double x, double y, double radius) {         System.out.printf("API1.circle at %f:%f radius %f\n", x, y, radius);     } } // concreteImplementor class DrawingAPI2 implements DrawingAPI{     @Override     public void drawCircle(double x, double y, double radius) {         System.out.printf("API1.circle at %f:%f radius %f\n", x, y, radius);     }    } // abstraction abstract class Shape{     protected DrawingAPI drawingAPI;     protected Shape(DrawingAPI drawingAPI){         this.drawingAPI = drawingAPI;     }         public abstract void draw();     public abstract void resizeByPercentage(double pct); } class CircleShape extends Shape{     private double x,y,radius;         public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI){         super(drawingAPI);         this.x = x;  this.y = y;  this.radius = radius;     }     @Override     public void draw() {         drawingAPI.drawCircle(x, y, radius);     }     @Override     public void resizeByPercentage(double pct) {         radius *= pct;     }     }

[vfvagabond-blog]

DP/07/24/SP: Adapter pattern

Idea is:

Adapter pattern also known as wrapper pattern or simply wrapper.

Translates one interface for a class into a compatible interface.

Allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface.

Also responsible for transforming data into appropriate forms.

Example:

Transforming the  format of dates(e.g YYYYMMDD to MM/DD/YYYY)

java.io.InputStreamReader(InputStream)

java.io.OutputStreamWriter(OutputStream)

Types: There are two types of adapter pattern.

 Class Adapter pattern

Object Adapter pattern

Class Adapter pattern: Inheritance is used to implement class adapter pattern. This type of adapter uses multiple polymorphic interface to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing.

Object Adapter pattern: In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object.

package com.designpattern.structuralpattern; /**  *  * @author palash  */ public class AdapterPattern {     public static void main(String[] args){               // class adapter pattern by inheritance         RectangularPlugClass clientPlug = new RectangularPlugClass("5amp", "15map");         System.out.println(clientPlug.getPower());                 // object adapter pattern by composition         RectangularPlugObject clientPlugObj = new RectangularPlugObject("7amp", "20amp");         System.out.println(clientPlugObj.getPower());     } } // class adapter pattern class CylindericalSocketClass{     public String supply(String cylinStem1, String cylinStem2){         System.out.println("Power...");         return cylinStem1 + " and " + cylinStem2 + " power supply from class adapter pattern";     } } class RectangularAdapterClass extends CylindericalSocketClass{     public String adapt(String rectaStem1, String rectaStem2){         String cylinStem1 = rectaStem1;         String cylinStem2 = rectaStem2;         return supply(cylinStem1, cylinStem2);     } } class RectangularPlugClass{     private String rectaStem1;     private String rectaStem2;     public RectangularPlugClass(String param1, String param2){         this.rectaStem1 = param1;         this.rectaStem2 = param2;     }         public String getPower(){         RectangularAdapterClass adapter = new RectangularAdapterClass();         String power = adapter.adapt(rectaStem1, rectaStem2);         return power;     } } /////////////////////////////////////////////// // Object adapter pattern class CylindericalSocketObject{     public String supply(String cylinStem1, String cylinStem2){         System.out.println("Power...");         return cylinStem1 + " and " + cylinStem2 + " power supply from object adapter pattern";     } } class RectangularAdapterObject{     private CylindericalSocketObject socket;         public String adapt(String rectaStem1, String rectaStem2){         socket = new CylindericalSocketObject();         String cylinStem1 = rectaStem1;         String cylinStem2 = rectaStem2;         return socket.supply(cylinStem1, cylinStem2);     } } class RectangularPlugObject{     private String rectaStem1;     private String rectaStem2;     public RectangularPlugObject(String param1, String param2){         this.rectaStem1 = param1;         this.rectaStem2 = param2;     }         public String getPower(){         RectangularAdapterObject adapter = new RectangularAdapterObject();         String power = adapter.adapt(rectaStem1, rectaStem2);         return power;     } }