In this tutorial I am going to explain about the adapter design pattern as part of the design patterns in Java series. Adapter design pattern is one of the structural design pattern because adapter design deals with how we make / structure an object. The primary problem this pattern trying to solve is to make it work two in-compatible interfaces. I think this gives the reason behind the term “adapter”.

There are two types of adapter design patterns:

1. Class Adapter : This type uses the Java inheritance to extend the class and then implement the adapter interface.
2. Object Adapter : This uses the Java composition where Adapter contains the source object.

In the below example I have used both the types of adapter pattern for your reference. I have taken the simple example of PowerGrid where the voltage is coming with high volume, I am using an adapter to convert that into lower levels. Note that this is very simple and concept remains the same even if you implement in the real time.
PowerGrid.java

[code lang=”java”]
class PowerGrid {
public int getPower() {
return 1000;
}
}
[/code]

PowerAdapter.java

[code lang=”java”]
interface PowerAdapter {
int get10V();

int get50V();

int get100V();
}
[/code]

PowerAdapterClassImpl.java

[code lang=”java”]
class PowerAdapterClassImpl extends PowerGrid implements PowerAdapter {
@Override
public int get10V() {
return (getPower() / 100);
}

@Override
public int get50V() {
return (getPower() / 20);
}

@Override
public int get100V() {
return (getPower() / 10);
}
}
[/code]

PowerAdapterObjectImpl.java

[code lang=”java”]
class PowerAdapterObjectImpl implements PowerAdapter {
private PowerGrid grid;

@Override
public int get10V() {
return (grid.getPower() / 100);
}

@Override
public int get50V() {
return (grid.getPower() / 20);
}

@Override
public int get100V() {
return (grid.getPower() / 10);
}
}
[/code]

AdapterDesignPatternExample.java

[code lang=”java”]
public class AdapterDesignPatternExample {
public static void main(String args[]) {
PowerAdapter classAdapter = new PowerAdapterClassImpl();
System.out.println(classAdapter.get100V());
System.out.println(classAdapter.get50V());
System.out.println(classAdapter.get10V());

PowerAdapter objectAdapter = new PowerAdapterObjectImpl();
System.out.println(objectAdapter.get100V());
System.out.println(objectAdapter.get50V());
System.out.println(objectAdapter.get10V());

}
}
[/code]

I hope this tutorial would have provided you very basic example and illustration to implement the adapter design pattern. If you have any interesting example for the adapter design pattern, please share with us in the comments section.

In this tutorial I am going to explain about builder design pattern, this is one of the most widely used design pattern in Java. Builder design pattern comes under the creational design pattern since builder design pattern helps in creating an object using step-by-step approach.

Subscribe to our future updates.

Builder design pattern solves the problem of creating an object with lot of parameters and where some of the parameters are mandatory and some are optional. The builder design pattern is very much similar to abstract factory design pattern. The key difference between abstract factory pattern and builder pattern is that, where in abstract factory pattern factory methods are creating the objects. But in builder pattern, clear instructions are given to the builder to with step-by-step approach for creating the objects. That means you have complete control on what to be included and excluded in the object creation.

(image source)

Builder Design Pattern Example

Here is a very simple example that demonstrates how to use builder design pattern for creating the objects. In this builder design pattern example, I am creating a Family object using the FamilyBuilder. Here if you notice, FamilyBuilder class is static class with each method adding one propery to the object. Finally, a build that completes the object creation. I hope that this example helps you understand how to use builder design pattern. If you have any questions, please write it in the comments section.
Family.java

[code lang=”java”]
package net.javabeat.designpatterns.builderpattern;

import java.util.List;

public class Family {
private String familyName;
private String husband;
private String wife;
private int numberOfKids;
private List<String> kidsNames;
private int annualIncome;
private boolean isCarOwned;
private boolean isHouseOwned;
private String city;
private String country;

private Family(FamilyBuilder builder){
this.familyName = builder.familyName;
this.husband = builder.husband;
this.wife = builder.wife;
this.numberOfKids = builder.numberOfKids;
this.kidsNames = builder.kidsNames;
this.annualIncome = builder.annualIncome;
this.isCarOwned = builder.isCarOwned;
this.isHouseOwned = builder.isHouseOwned;
this.city = builder.city;
this.country = builder.country;
}
//All getter, and NO setter to provide immutability
public String getFamilyName() {
return familyName;
}

public String getHusband() {
return husband;
}

public String getWife() {
return wife;
}

public int getNumberOfKids() {
return numberOfKids;
}

public List<String> getKidsNames() {
return kidsNames;
}

public int getAnnualIncome() {
return annualIncome;
}

public boolean isCarOwned() {
return isCarOwned;
}

public boolean isHouseOwned() {
return isHouseOwned;
}

public String getCity() {
return city;
}

public String getCountry() {
return country;
}

public String toString(){
StringBuilder result = new StringBuilder();
result.append("Family Name : "+this.familyName);
result.append("\nHusband Name : "+this.husband);
result.append("\nWife Name : "+this.wife);
result.append("\nNumber of Kids : "+this.numberOfKids);
result.append("\nKids Names : "+this.kidsNames);
result.append("\nAnnual Income : "+this.annualIncome);
result.append("\nIs Own Car : "+this.isCarOwned);
result.append("\nIs Own House : "+this.isHouseOwned);
result.append("\nCity : "+this.city);
result.append("\nCountry : "+this.country);
return result.toString();
}

public static class FamilyBuilder{
private String familyName;
private String husband;
private String wife;
private int numberOfKids;
private List<String> kidsNames;
private int annualIncome;
private boolean isCarOwned;
private boolean isHouseOwned;
private String city;
private String country;
public FamilyBuilder(String familyName){
this.familyName = familyName;
}
FamilyBuilder husband(String husband){
this.husband = husband;
return this;
}
FamilyBuilder wife(String wife){
this.wife = wife;
return this;
}
FamilyBuilder kids(int kids){
this.numberOfKids = kids;
return this;
}
FamilyBuilder kidsNames(List kidsNames){
this.kidsNames = kidsNames;
return this;
}
FamilyBuilder annualIncome(int annualIncome){
this.annualIncome = annualIncome;
return this;
}
FamilyBuilder isCarOwned(boolean isCarOwned){
this.isCarOwned = isCarOwned;
return this;
}
FamilyBuilder isHouseOwned(boolean isHouseOwned){
this.isHouseOwned = isHouseOwned;
return this;
}
FamilyBuilder city(String city){
this.city = city;
return this;
}
FamilyBuilder country(String country){
this.country = country;
return this;
}
//Return the finally construcuted Family object
public Family build() {
Family family = new Family(this);
return family;
}
}
}
[/code]

BuilderDesignPatternExample.java

[code lang=”java”]
package net.javabeat.designpatterns.builderpattern;

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

public class BuilderDesignPatternExample {

public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("Nancy");
Family family = new Family.FamilyBuilder("Happy Family").husband("John").wife("Marry").
kids(1).kidsNames(list).annualIncome(100000).isCarOwned(true).
isHouseOwned(true).city("NewYork").country("USA").build();
System.out.println(family);
}
}
[/code]

This tutorial explains the state design pattern with a simple example program. State design pattern is very similar to the Strategy pattern, the only difference is that state design pattern maintains the state of the context where as strategy pattern passes the context and execute the specific strategy.

The state design pattern is very useful in the scenarios where sequence of actions are taken with the pre-defined order. A perfect example is the lifecycle methods executed in a framework. Each phase is invoked one after the another by looking at the current phase of the context. I have used the lifecycle example for explaining the state design pattern example.

• State operation will be declared as interface. Actual implementations will have the specific states with reference to the next state.
• State context is where state instantiated with the initial state. State contact will declare a constructor to initialize state.
• When you invoke the operation, it will keep moving to the different states for each execution.

State.java

[code lang=”java”]
package javabeat.net.pattern;

public interface State {
public void execute(StateContext context);
}
[/code]

StateOne.java

[code lang=”java”]
package javabeat.net.pattern;

public class StateOne implements State{
public void execute(StateContext context){
System.out.println("State One Executed!!");
context.setState(new StateTwo());
}
}
[/code]

StateTwo.java

[code lang=”java”]
package javabeat.net.pattern;

public class StateTwo implements State {
public void execute(StateContext context){
System.out.println("State Two Executed!!");
context.setState(new StateThree());
}
}
[/code]

StateThree.java

[code lang=”java”]
package javabeat.net.pattern;

public class StateThree implements State{
public void execute(StateContext context){
System.out.println("State Three Executed!!");
}
}
[/code]

StateContext.java

[code lang=”java”]
package javabeat.net.pattern;

public class StateContext {
State state = null;
public StateContext(State state){
this.setState(new StateOne());
}
public void setState(State state){
this.state = state;
}

public void runLifeCycle(){
state.execute(this);
}
}
[/code]

StatePatternExample.java

[code lang=”java”]
package javabeat.net.pattern;

/**
* State design pattern example
*
* @author Krishna
*
*/
public class StatePatternExample {
public static void main(String[] args) {
//Create state context
StateContext context = new StateContext(new StateOne());

//Invoke operation from state context
context.runLifeCycle();
context.runLifeCycle();
context.runLifeCycle();
}
}
[/code]

Output…

[code]
State One Executed!!
State Two Executed!!
State Three Executed!!
[/code]

• We have implemented State interface to execute each state.
• StateOne, StateTwo and StateThree are the three states we have implemented using the State interface.
• StateContext is the actual context where the state would be invoked. You can consider this as your main application.

You can run the StatePatternExample class to test the State Design Pattern.

In developing a system, it is expected that some requirements are guaranteed, for example, performance, robustness, understanding, ease of reuse, modification, and use. The Design Patterns were created by the architect Christopher Alexander , in the 1970s. During this period the architect wrote two books: “Pattern Language” and “Timeless Way of Building“. These books were an example of how Christopher thought in order to document these patterns.

If you are interested in receiving updates, please subscribe our newsletter.

In 1995, the professionals: Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides , wrote and released the book called “Design Patterns: Elements of Reusable Object-Oriented Software”, which shows the details of the 23 Design Patterns. For this achievement, the professionals were baptized with the name “Gang of Four” (Gang of Four or GoF).

The goal of design patterns are:

• Reusable components that make it easy to standardize.
• Enabling agile solutions for recurring problems in developing the system.

There are two design patterns known to software engineering. Those are:

• Standard GoF (Gang of Four) patterns
• GRASP (General Responsibility Assignment Software Patterns).

GRASP Design Patterns

• Design Pattern Interview Questions

These patterns consists of guidelines for assigning responsibility to classes and objects in object-oriented design. The different patterns and principles and standards used in GRASP  design patterns are:

• Specialist in information
• Creator
• Controller
• Weak coupling
• High Cohesion
• Polymorphism
• Pure Fabrication
• Indirection
• Protected Variations

GoF Design Patterns

These patterns consist of three groups as shown below:

• Creational Patterns
  • Factory Method
  • Abstract Factory
  • Singleton, Builder
  • Prototype
• Structural Patterns
  • Adapter
  • Bridge
  • Composite
  • Decorator
  • Facade
  • Flyweight
  • Proxy
• Behavioral Patterns
  • Chain of Responsibility
  • Command
  • Interpreter
  • Iterator
  • Mediator
  • Memento
  • Observer
  • State
  • Strategy
  • Template
  • Method
  • Visitor.

GoF Design Patterns of Creation

The patterns of this type require a treatment of how objects (classes) are created to meet the diverse needs. In Java, objects are instantiated through their builders, but the use of them is limited when:

• The code that references the creation of an object needs to know the builders of it, it increases the coupling of classes.
• The object can not be created partially.
• The builder can not control the number of instances in the present application.

Figure 1 : Illustration of the figurative Pattern GoF Creation

• Factory Method : This standard defines an interface for creating an object, letting the subclasses remain responsible for deciding which class to instantiate.
• Abstract Factory : Allows you to draw an interface for creating families of related objects or interdependent, not specifying their concrete classes. These standards can be created using concrete factories, which are responsible for the creation of new objects to meet customer needs. Therefore, this practice helps to exclude the dependency between the client and the class of objects used by the client.
• Singleton : Used when desired, that a class has only one instance of the application. Below are some aspects that should be taken care of when creating this pattern:
• The class is final, it does not allow the creation of subclasses of the class itself.
• Access is granted through the method that returns a single instance of the class, or is creating one, if it has not been created.
• Builder : Provides a generic interface for the incremental construction of aggregations. This pattern hides the details of how the components are created, composed and represented.
• Prototype : Defines the types of objects to be created from an instance that serves as a prototype. New objects are created based on this prototype.

GoF Structural Design Patterns

This standard describes the following aspects: preparation, organization and association between objects and classes / interfaces. Allows to combine objects into more complex structures, or describe how the classes are inherited or composed from other.

Figure 2 : Illustration GoF Structural Pattern

• Adapter : The action of this pattern converts the interface of a class into another, expected by the client object. Through this conversion, allows classes with incompatible interfaces, able to be adapted so that other objects can work together.
• Bridge : This pattern separates an abstraction from its implementation, allowing both to work independently, and establishes a bridge between them.
• Composite : Consisting of objects aggregation trees. Aggregate objects are treated as a single object.
• Decorator : This standard seeks to offer a flexible alternative to extension object dynamic new features, without the use of inheritance. An example is the use of the scroll bar that can be incorporated dynamically to a window, text box or web page.
• Facade : Provides a unified interface to a set of objects that consists of a subsystem, defining a high-level interface that facilitates the use.
• Flyweight : Use sharing to support efficiently to a large number of objects with high level of granularity. This pattern creates models for each object, which concentrates all the common features of an object.
• Proxy : Allows access is controlled by another object, which acts as a substitute. Generally used in aspect-oriented programming, aiming to help sort, wrap, modularizing methods and organize code according to importance.

GoF Behavioural Patterns

These patterns show the process of how objects or classes communicate. In general, look for a loose coupling between objects, although the communication that exists between them.

Figure 3 : Illustration of GoF Behavioral Pattern

• Chain of Responsibility : This design pattern consists of a source of command objects and a series of processing objects. Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain. A mechanism also exists for adding new processing objects to the end of this chain.
• Command : encapsulates a message or request as an object, so that it can set parameters with different messaging clients.
• Interpreter : Are representations and abstractions for grammars for parsing, being used for more language definition.
• Iterator : Used to provide a way to access elements of a collection of objects sequentially without exposing the internal structures.
• Mediator : This pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to be a behavioral pattern due to the way it can alter the program’s running behavior.
• Memento : Works as a “snapshot”, it captures and externalizes the internal state of an object without violating encapsulation, allowing the object can be restored to this state in the future. One example is operations that need to be reversed, so that the previous state of the object is then restored.
• Observer : Used to synchronize, coordinate and maintain consistency between related objects which have one to many dependency between objects, ie, when the state of an object changes, all dependents are notified and updated automatically.
• State : This patter encapsulates varying behavior for the same routine based on an object’s state object. This can be a cleaner way for an object to change its behavior at runtime without resorting to large monolithic conditional statements.
• Strategy : Defines a new set of algorithms without changing the classes of the elements on which it operates.
• Template Method : This pattern defines the program skeleton of an algorithm in a method, called template method, which defers some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm’s structure.
• Visitor : It is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. It is one way to follow the open/closed principle.

Summary

• Design pattern interview questions

In this article, we saw types of design patterns GoF patterns and GRASP. We also saw further categorization in each of these patterns. This article aims at giving a basic knowledge of design patterns. With this basic knowledge you can proceed to understand each of these patterns better and implement in your day to day software applications.

Lazy Initialization

Lazy Initialization is a technique where one postpones the instantiation of a object until its first use. In other words the instance of a class is created when its required to be used for the first time. The idea behind this is to avoid unnecessary instance creation. But there are concerns related to using such approaches in a concurrent scenario. But before that lets see how lazy initialization looks:

also read:

• Design Pattern Interview Questions
• Factory Design Pattern
• State design pattern

[code lang=”java”]
class ResourceManager{
private Resource resource;
public Resource getResource(){
if ( resource == null ){
resource = new Resource();
}
return resource;
}
}
[/code]
When the above code is executed in a multi threaded program the concern that immediately comes to the mind is the “Race condition”.
Thread A would check that resource == null so it goes inside to create the instance but might go into Runnable status before it creates the Resource instance.
Thread B also checks that resource == null and it goes ahead, creates the instance and uses it for its operations.
Thread A comes back to running status and it also continues to create its own instance and start using it.

Now in the above case suppose we wanted both Thread A and Thread B to work on the same instance, but due to the race condition they would work on different instances. If the Resource instances has state information associated with it then it because a critical problem. Lets stop here and then see how Singleton is related to this.

Singleton

Singleton is one of the Creational Design Patterns discussed in the GoF Design Patterns. The main idea behind the Singleton pattern is to control the creation of objects for a given class such that at any time there’s only one instance of that particular class. So lets see how we can implement the Singleton pattern:

[code lang=”java”]
class Resource{
private static Resource instance;
public static Resource getInstance(){
if ( instance == null){
instance = new Resource();
}
return instance;
}
}
[/code]
where in the above example Resource is a singleton. This is very similar to the concept of lazy initialization and this as well suffers from the issues seen while using this is a multi threaded environment/program.

Double Checked Locking

One way to solve the problem with Lazy initialization and singleton in a multi threaded program is to declare the getInstance() or getResource() method as synchronized. But its a huge overhead because everytime the method is invoked it has to go through the process of waiting for the lock and then obtaining the lock and its unnecessary because its only once that the instance is created and all subsequent invocations would just return that instance.

To work around this issue, Double Checked Locking is the pattern used. In this approach the methods are not synchronized instead the instance creation code is put in a synchronized block. Let me show an example:
[code lang=”java”]
class Resource{
private static Resource instance;
public static Resource getInstance(){
if ( instance == null ){
synchronized(Resource.class){
if ( instance == null ){
instance = new Resource();
}
}/end of synchronized block.
}
return instance;
}
}
[/code]
In the above code there are two null checks- one outside the synchronized block and one within it. The synchronized block is executed at most once and any other thread trying to get instance would have to wait until the instantiation to complete.

The above approach also has some issues. The initialization of an object and the creation of instance of that class are 2 different operations. Once the instance of the class has been created that instance is then used to initialize the values of its state either with default values or some user defined values. Now between these 2 operations another thread might invoke the method to get the instance and sees that the instance is already not null and then proceeds with using that instance. Though its the correct instance we wanted the thread to use but that instance hasn’t been initialized yet. This issue is called as Unsafe Publication. Java Concurrency in Practice book has a really good chapter on Java Memory Model and issues related to Safe Publication and Unsafe Publication of instances.

Lazy Initialization holder class idiom

One can read about this Lazy Initialization holder class Idiom in the interview with Joshua Bloch here. It has been covered in Effective Java by Joshua Bloch and also in Java Concurrency in Practice. Let me just share that idea here:
[code lang=”java”]
class Resource{
private static class ResourceHolder{
static final Resource instance = new Resource();
}
public static Resource getInstance(){
return ResourceHolder.instance;
}
}
[/code]
This takes advantage of:

• Eager Initialization
• Class not initialized unless its used/loaded by the class loader the first time its used.

Another interesting discussion related to this on JavaRanch.

This tutorial explain the basic concept of decorator design pattern and how to use them. This is one of the pattern I have published as part of our Design pattern in Java series. If you are interested in receiving updates, please subscribe our newsletter.

Intent of Decorator Design Pattern:

• Attach additional responsibilities to an object dynamically.Decorators provide a flexible alternative to subclassing for extending functionality.[GoF,p175]
• Client specified embellishment of a core object by recursively wrapping it.
• Wrapping a gift,putting it in a box and wrapping the box.

also read:

• Design Pattern Interview Questions
• Factory Design Pattern
• State design pattern

Problem:You want to add behavior or state to individual objects at runtime.Inheritance is not feasible because it is static and applies to an entire class.

Solution:Attach additional logic to an existing object.Use Delegation.Place an object in front of it that delegates calls to the original object and then makes needed changes before returning the value.This is a form of linked list.

Structural Summary:

• Identify if the client would like to dynamically embellish a core object.
• Start with a composite design and change the 1-to-many recursive relationship to 1-1.
• Define each “embellishment” class a derived class of the class whose role has morphed from “Composite” to “Decorator”.
• The client can now wrap a “core” object with any number of Decorator objects.Each decorator contributes its “embellishment” functionality and then delegates to its wrappee.

Decorator Design Pattern

Decorator Pattern involves encapsulating the original object inside an abstract wrapper interface.Both the decorator objects and the core object inherit from this abstract interface.

The interface uses recursive composition to allow an unlimited number of decorator “layers” to be added to each core object.Note that this pattern allows responsibilities to be added to an object,not methods to an object’s interface.

This interface presented to the client must remain constant as successive layers are specified.Also note that the core object identity has now been “hidden” inside of a decorator object.Trying to access core object is now a problem.

• Factory Pattern
• Template Pattern
• Abstract Factory Pattern

The Decorator attaches additional responsibilities to an object dynamically. The ornaments that are added to pine or fir trees are examples of Decorators. Lights, garland, candy canes, glass ornaments, etc., can be added to a tree to give it a festive look. The ornaments do not change the tree itself which is recognizable as a Christmas tree regardless of particular ornaments used. As an example of additional functionality, the addition of lights allows one to “light up” a Christmas tree.

Decorator Design Pattern

One class takes in another class both of which extend the same abstract class,and adds functionality.Decorator Pattern helps to add behavior or responsibilities to an object.This is also called “wrapper”.

Java Design Patterns suggest that decorators should be abstract classes and the concrete implementation should be derived from them.Decorator and Adapter patterns are similar.Adapter also seems to decorate classes.

The intent of using adapter is to convert the interface of one or more classes to suit the interface of the client program.In case of decorator,the intent is to add behavior and functionality to some of the objects,not all the objects or adding different functionalities to each of the objects.Can also be called as “Wrapper”.

( Image Credit )

This pattern can also be used as a way to refactor a complex class into smaller pieces.Even if we donot need to attach responsibilities dynamically it can be clearer to have each responsibility in a different class.

Only disadvantage is code maintenance can be a problem as it provides the system with a lot of similar looking small objects(each decorator).

Difference that we see between a decorator pattern and subclassing is that we can decorate any class that implements an interface with a single class.Say we wanted to give ourselves a java.util.Map that printed a message whenever as added or removed a key.

We may create a subclass of HashMap i.e PrintableMap and override put and remove methods.But if we wanted to create a printable version of TreeMap then we either create PrintableTreeMap which has almost identical code to PrintableMap?(which should itself become PrintingHashMap) or we create a Map decorator.

Important Points about Decorator Design Pattern:

• Ensure the context is: a single core(or non-optional) component,several optional wrappers and an interface that is commonto all.
• Create a “Lowest Common Denominator” interface that makes all classes interchangeable.
• Create a second level base class(Decorator) to support the optional wrapper classes.
• Core class and Decorator class inherit from LCD interface.
• Decorator class declares a composition relationship to the LCD interface,and this data member is initialized in its constructor.
• Decorator class delegates to the LCD object.
• Define a Decorator Derived class for each object embellishment.
• Decorator derived classes implement their wrapper functinality and delegate to the Decorator base class.
• 9) Client configures the type and ordering of Core and Decorator objects.

Rules of Thumb:
Adapter provides a different interface to its subject.Proxy provides the same interface.Decorator provides an enhanced interface.[GoF, p216]

Adapter changes the object’s interface,Decorator enhances an object’s responsibilities.Decorator is thus more transparent to the client.As a consequence,Decorator supports recursive composition,which isnt possible with pure Adapters.[GoF, p149]

Composite and Decorator have similar structure diagrams,reflecting the fact that both rely on recursive composition to organize an open-ended number of objects.[GoF, p219]

A Decorator can be viewed as a degenerate Composite with only one component.However a decorator adds additional responsibilities-it isnt intended for object aggregation.[GoF, p184]

Decorator is designed to let you add responsibilites to objects without subclassing.Composite’s focus is not an embellishment but on representation.These intents are distinct but complementary.Consequently Composite and Decorator are often used in concert. [GoF, p220]

Decorator lets us change the skin of an object.Strategy lets us change the guts.[GoF, p184]

Decorator and Proxy have diff purposes but similar structures.Both describe how to provide a level of indirection to another object,and the implementations keep a reference to the object to which they forward requests.[GoF, p220]

Below example gives one implementation of Decorator Pattern used in our project.Please note that we are using Apache Beehieve for our front-end application.

In our project we have a requirement to encrpt all the input data shown in jsp pages.Actually the idea and implementation was done by one developer named Sai Selvam in our project.Thankfully all of us learned from him.

Below are the steps:-

1) Create a class Crypto which extends from org.apache.beehive.netui.tags.html.Parameter class and overside setName and setValue methods and set the encrpyted names and values instead.

[code lang=”java”]public class Crypto extends Parameter
@Override
public void setName(String arg0)
super.setName(CryptoUtil.encrypt(arg0));
@Override
public void setValue(Object arg0) throws JspException
super.setValue(CryptoUtil.encrypt(String.valueOf(arg0)));
}[/code]

Please note that CryptoUtil is our project related class and we using BASE64Decoder and BASE64Encoder classes for achieving encryption and decryption which we will not be discussing in this article.Please refer manual (sun.misc.BASE64Decoder and sun.misc.BASE64Encoder) for further details.

2) Create a URLRewriteFilter class which acts as a filter i.e implements Filter interface.Cast the request object to CryptoWrappedRequest wrapper class which is extending from HttpServletRequestWrapper class.

[code lang=”java”]
public void doFilter(ServletRequest pRequest , ServletResponse pResponse,
FilterChain pChain) throws IOException , ServletException {
if (pRequest instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) pRequest;
HttpServletResponse response = (HttpServletResponse) pResponse;
CryptoWrappedRequest cryptoWrappedRequest = new CryptoWrappedRequest(request , response);
cryptoWrappedRequest.getRequestDispatcher(request.getServletPath()).forward(cryptoWrappedRequest , response);
if (!response.isCommitted()) {
pChain.doFilter(request , response);}[/code]

3) Create CryptoWrappedRequest class which extends from HttpServletRequestWrapper class and provides additional functinalities.

[code lang=”java”]
import org.apache.beehive.netui.pageflow.PageFlowUtils;
import org.apache.beehive.netui.pageflow.internal.PageFlowRequestWrapper;
public class CryptoWrappedRequest extends HttpServletRequestWrapper {
private PageFlowRequestWrapper pageFlowRequestWrapper;
private String newQueryString = null;
private Map<String, String[]> params = null;
public CryptoWrappedRequest(HttpServletRequest request , HttpServletResponse response) {
super(request);
pageFlowRequestWrapper = PageFlowRequestWrapper.wrapRequest(request);
}

@Override
public String getQueryString() {
if (newQueryString == null)
constructQueryString(pageFlowRequestWrapper.getQueryString());
return newQueryString;
}

// If the request has some query parameters appended to the URL then we decrypt key,value pairs and then
// append and form the newQueryString text approximately.If there is no data appended newQueryString value remains the same old value
//retrieved from pageFlowRequestWrapper.

protected void constructQueryString(String encryptedQueryString) {
if (encryptedQueryString != null &amp;amp;&amp;amp; encryptedQueryString.length() > 0) {
for(String param : encryptedQueryString.split("&amp;amp;")) {
String[] paramNameValuePair = param.split("=");
try {
if(paramNameValuePair.length>1)
{
String paramName = URLDecoder.decode(paramNameValuePair[0] , "UTF-8");
String paramValue = URLDecoder.decode(paramNameValuePair[1] , "UTF-8");
addToQueryString(paramName , paramValue);
}
}
catch (UnsupportedEncodingException e) {
//e.printStackTrace();
}
catch (Exception ex) {
//e.printStackTrace();
}
}
} else {
newQueryString = encryptedQueryString;
}
}

// This Method tries to decrypt the key and value before forming the newQueryString value.
protected void addToQueryString(String paramKey, String paramValue) {
String pmKeyDecrypted = CryptoUtil.decrypt(paramKey);
String pmValueDecrypted = CryptoUtil.decrypt(paramValue);

if (pmKeyDecrypted == null) { pmKeyDecrypted = paramKey; }
if (pmValueDecrypted == null) { pmValueDecrypted = paramValue; }

if (newQueryString == null) { newQueryString = ""; }
StringBuffer newQS = new StringBuffer(newQueryString);
if (newQS.length() > 0) { newQS.append("&amp;amp;"); }
newQS.append(pmKeyDecrypted);
newQS.append("=");
newQS.append(pmValueDecrypted);
newQueryString = newQS.toString();
}

@Override
public String getParameter(String paramName) {
if (pageFlowRequestWrapper.getParameter(paramName) != null) {
return pageFlowRequestWrapper.getParameter(paramName);
}
else if (pageFlowRequestWrapper.getParameter(CryptoUtil.encrypt(paramName)) != null) {
return CryptoUtil.decrypt(pageFlowRequestWrapper.getParameter(CryptoUtil.encrypt(paramName)));
}
return null;
}

@Override
public Enumeration getParameterNames() {
List<String> resultList = new ArrayList<String>();
Enumeration enn = pageFlowRequestWrapper.getParameterNames();
while(enn.hasMoreElements()) {
String paramName = (String)enn.nextElement();
String newName = CryptoUtil.decrypt(paramName);
if (newName != null) {
resultList.add(newName);
} else {
resultList.add(paramName);
}
}
return Collections.enumeration(resultList);
}

@Override
public String[] getParameterValues(String paramName) {
String[] result = null;
List<String> resultList = new ArrayList<String>();

String[] paramValues = pageFlowRequestWrapper.getParameterValues(paramName);
if (paramValues == null || paramValues.length == 0)
paramValues = pageFlowRequestWrapper.getParameterValues(CryptoUtil.encrypt(paramName));

if (paramValues != null &amp;amp;&amp;amp; paramValues.length > 0) {
for(String paramValue : paramValues) {
String newValue = CryptoUtil.decrypt(paramValue);
if (newValue != null)
resultList.add(newValue);
else
resultList.add(paramValue);
}
}

if (resultList.size() > 0) {
result = new String[resultList.size()];
resultList.toArray(result);
}

return result;
}

@Override
public Map getParameterMap()
{
if (params == null)
processParameters(pageFlowRequestWrapper.getParameterMap());

return params;
}

protected void processParameters(Map pm) {
//Map pm = pageFlowRequestWrapper.getParameterMap();
if (pm != null) {
params = new HashMap<String , String[]>();
Iterator pmIter = pm.keySet().iterator();
while(pmIter.hasNext()) {
String pmKey = (String) pmIter.next();
if (!pmKey.startsWith(PageFlowUtils.ACTION_OVERRIDE_PREFIX)) {
String pmKeyDecrypted = CryptoUtil.decrypt(pmKey);
if (pmKeyDecrypted == null) pmKeyDecrypted = pmKey;
for(String pmValue : (String[]) pm.get(pmKey)) {
String pmValueDecrypted = CryptoUtil.decrypt(pmValue);
if (pmValueDecrypted == null) pmValueDecrypted = pmValue;
addToParams(pmKeyDecrypted , pmValueDecrypted);
}
}
}
} else {
params = null;
}
}

protected void addToParams(String paramKey , String paramValue) {
List<String> listObj = new ArrayList<String>();

if (params.containsKey(paramKey)) {
Iterator iter = Arrays.asList((String[]) params.get(paramKey)).iterator();
while(iter.hasNext()) {
listObj.add((String) iter.next());
}
}
listObj.add(paramValue);
String[] strArray = new String[listObj.size()];
listObj.toArray(strArray);
params.put(paramKey , strArray);
}

}[/code]

4) Add entries in web.xml for Filter class and the Cryto tag which we defined in Step 1.Also create a .tld file refering to our cryto class.

5) Finally in jsp for any input parameter we will be sending we will write code similar to this.

[code lang=”java”]<crypto:EncryptParamter name="somename" value="value"/>[/code]

What is Iterator Pattern?

Provide a way to access the elements of the aggregate object sequentially without exposing its underlying representation.
Aggregate object is an object that contains other objects for the purpose of grouping those objects as a unit.It is also called a container or a collection.Examples are linkedList,Hashtable,ArrayList etc.

also read:

• Design Pattern Interview Questions
• Factory Design Pattern
• State design pattern

Motivation

• Aggregate object such as a list should allow a way to traverse its elements without exposing its internal structure.
• It should allow different traversal methods.
• It should allow multiple traversals to be in progress concurrently.
• But we really donot want to add all these methods to the interface for the aggregate.

Use of Iterator Pattern

• To Support traversals of aggregate objects without exposing their internal representation.
• To support multiple,concurrent traversals of aggregate objects.
• To provide a uniform interface for traversing different aggregate structures
  (that is, to support polymorphic iteration)

Related Patterns

• Composite – Iterators are often used to recursively traverse composite structures.
• Factory Method – Polymorphic iterators use factory methods to instantiate the appropriate iterator subclass.

Iterator Pattern is one which allows us to navigate through a collection of data using a common interface without knowing its underlying implementation.Iterator Pattern should be implemented as interface.This allows every user to implement it in the manner which most likely suits the requirement.

One Real time example of Iterator Pattern is the usage of Remote Controls in Home.Any Remote Control we use to start pressing up and down and back keys to iterate through the channels.

What sort of interface can Iterator be in case of Remote Controls?

One Example Implementation might be:

[code lang=”java”]
public interface Iterator {
public Channel nextChannel(int currentChannel);
public Channel previousChannel(int currentChannel);
}
[/code]

The Channel iterator is common for all the remote controls.It’s like a specification implemented by all the remote control manufacturing companies.

[code lang=”java”]
public ChannelSurfer implements Iterator {

public Channel nextChannel(int currentChannel) {
Channel channel=new Channel(currentChannel+1);
return channel;
}

public Channel previousChannel(int currentChannel) {
Channel channel=new Channel(currentChannel-1);
return channel;
}
}

public class RemoteControl {

private ChannelSurfer surfer;

public RemoteControl() {
surfer=new ChannelSurfer();
}

public Program getProgram(ChannelSurfer surfer) {
return new Program(surfer.nextChannel());
}
}

public Program {

// … Some specific implementation of Program class.
}
[/code]

We all know that every channel is associated with program and it’s basically the program and not the channel number which a user wants to see.This applies that we can apply some logic before returning the elements through iterator.Iterator here can also be programmed to return ‘the programs’ straight away rather than returning the channels.

Common Java Iterator is Iterator itself.Interface Signature has been copied from the javadoc.

An iterator over a collection. Iterator takes the place of Enumeration in the Java collections framework. Iterators differ from enumerations in two ways:
Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
Method names have been improved.

[code lang=”java”]
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}
[/code]

java.util.Collection interface a root interface in Collections hierarchy contains a method iterator() which returns the Iterator interface.Hence any class implementing Collection interface should provide definition for iterator() method.But please note that there are no Guarantees concerning the order(unless this collection is an instance of some class that provides a guarantee) as List by definition guarantees ordered Collection.

When we try to view List interface which extends Collection interface it has a method iterator() which returns an Iterator over the elements in this list in proper sequence.

Now coming to ArrayList a subclass class implementing List interface – which also extends AbstractList class provides definition for iterator() method.Infact all the underlying logic sits in AbstractList class.

When we try to view code it tries to return a Itr innerClass object.

[code lang=”java”]
public Iterator<E> iterator() {
return new Itr();
}

public E remove(int index) {
throw new UnsupportedOperationException();
}
[/code]

Now finally when we try to go through code of Itr we can see that this class implements Iterator interface naturally and provides definition for all methods.

Let us try to view few important parts of the code:

[code lang=”java”]
private class Itr implements Iterator<E> {

/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;

/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;

/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;

// Note that size() returns the no of elements count in the list.
public boolean hasNext() {
return cursor!=size();
}

public E next() {
checkForComodification();
try {
E next=get(cursor);
// Please note that the implementation for get() method is defined in indivudual subclasses like ArrayList class rather than AbstractList itself.
lastRet=cursor++;
return next;
}catch(IndexOutOfBoundsException ie) {
checkForComodification();
throw new NoSuchElementModification();
}
}

public void remove() {
if(lastRet==-1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet); // Please note that remove method will be called depending on the object called.Also an exception is thrown in the remove() method implementation of AbstractList class.

if (lastRet < cursor)
cursor–;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}

}

final void checkForComodification() {
if(modCount!=expectedModCount)
throw new ConcurrentModificationException();
}

}
[/code]

When we try to peep code of ArrayList class to check the implementation of get() method we find:

[code lang=”java”]
public E get(int index) {
RangeCheck(index);
return elementData[index]; // elementData is an array of type E.
}

/**
* Check if the given index is in range. If not, throw an appropriate
* runtime exception. This method does *not* check if the index is
* negative: It is always used immediately prior to an array access,
* which throws an ArrayIndexOutOfBoundsException if index is negative.
*/
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}

When we try to view remove() method logic in ArrayList.

public E remove(int index) {
RangeCheck(index);

modCount++;
E oldValue = elementData[index];

int numMoved = size – index – 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[–size] = null;

return oldValue;
}

[/code]

It clearly tries to remove the specified element by shifting other if remaining elements to left and nullifies last element to null just to make sure if the user is trying to remove last element and finally returns back the value of the element to be removed.

This tutorial explain the basic concept of abstract factory design pattern and how to use them. This is one of the pattern I have published as part of our Design pattern in Java series. If you are interested in receiving updates, please subscribe our newsletter.

What is Abstract Factory Design Pattern?

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

Wikipedia says:
A software design pattern, the Abstract Factory Pattern provides a way to encapsulate a group of individual factories that have a common theme.

also read:

• Design Pattern Interview Questions
• Factory Design Pattern
• State design pattern

Intent:
Define an interface for creating an object,but let subclasses decide which class to instantiate.
Factory method lets a class instantiation to subclasses.

Motto: Hence depend on abstractions and not on concrete classes.Intent of Abstract Factory is to create families of related objects without having to depend on their concrete classes.A Simple Abstract Factory is a way to decouple our clients from concrete classes.Abstract Factory relies on Object Composition.Object creation is implemented in methods exposed in the factory interface.[GoF,162]

Purpose:
To create a contract for creating families of related or dependent objects without having to specify their concrete classes.

Introduction:
Suppose we plan to manage address and telephone information in our application(Example Personal Informational manager) system.We will initially produce classes to represent Address and Telephone number data.Code these classes so that they store the relavent information and enforce business rules about their format.Ex: In few indian cities all telephone numbers are limited to 7 digits.Shortly we get another requirement to manage this application for another city/country.So we modify our logic in the Address and PhoneNumber to satisfy rules for another city/country and all of a sudden after managing for many countries sees our classes get bloated with code and difficult to manage. With every country added, we need to modify and recompile the classes to manage contact information.

It’s better to flexibly add these paired classes to the system;to take the general rules that apply to address and phone number data,and allow any number of possible foreign variations to be “loaded” into a system.

The abstract factory solves this problem.Using this pattern,you define an AddressFactory- a generic framework for producing objects that follow the general pattern for an Address and PhoneNumber.At runtime,this factory is paired with any number of concrete factories for different countries,and each country has its own version of Address and PhoneNumber classes.

Instead of going through nightmare of adding functional logic to the classes,extend the Address to USAddress and PhoneNumber to USPhoneNumber for country US.Instances of both classes are created by USAddressFactory.This gives greater freedom to extend your code without having to make major structural modifications in the rest of the system.

Applicability:
Use the Abstract Factory Pattern when:

• The client should be independent of how the products are created.
• Application should be configured with one of multiple families of products.
• Objects needs to be created as a set,in order to be compatible.
• You want to provide a collection of classes and you want to reveal just their contracts and their relationships,not their implementations.

Description:
During runtime,ConcreteFactories and ConcreteProducts are created and used by the application.The concrete classes conform to the contract defined by the AbstractFactory and AbstractProducts so the concrete classes can be directly used,without being recoded or recompiled.

We typically use the following to implement the Abstract Factory Pattern:

• AbstractFactory – An abstract class or interface that defines the create methods for abstract products.
• AbstractProduct – An abstract class or interface that describing the general behavior of the resource that will be used by the application.
• ConcreteFactory – A class derived from the abstract factory.It implements create methods for one or more concrete products.
• ConcreteProduct – A class derived from the abstract product,providing an implementation for a specific resource or operating environment.

Benefits and Drawbacks

Abstract Factory helps to increase the overall flexibility of the application.Flexibility manifests itself both during runtime and design time.During design we donot have to predict all future uses of this application.Instead we create a generic framework,and develop implementations independently from the rest of the application.At runtime,application can easily integrate new features and resources.

A further benefit of this pattern is it simplifies testing the rest of the application.

As discussed,we can define the AbstractFactory and AbstractProduct as an interface or an abstract class depending on the needs of the application and your preference.

Depending on how the factory is to be used,some variations of this pattern allow multiple ConcreteFactory objects to be produced,resulting in an application that can simultaneously use multiple families of ConcreteProducts.

Related Patterns

• Factory Method – Used to implement Abstract Factory.
• Singleton – Often Used in Concrete Factory.
• Data Access Object – The Data Access Object pattern can use the Abstract Factory Pattern to add flexibility in creating Database-specific factories.

Implementation Issues

How many instances of a particular concrete factory should there be?

• An application typically only needs a single instance of a particular concrete factory
• Use the Singleton pattern for this purpose

Below example describes implementation of Abstract Factory.

[code lang=”java”]

package patterns;

interface AddressFactory {

public Address createAddress();
public PhoneNumber createPhoneNumber();
}

abstract class Address {
private String street;
private String city;
private String region;
private String postalCode;

public static final String EOL_STRING =System.getProperty("line.separator");
public static final String SPACE = " ";

public String getStreet() {
return street;
}
public String getCity() {
return city;
}
public String getPostalCode() {
return postalCode;
}
public String getRegion() {
return region;
}
public abstract String getCountry();

public String getFullAddress() {
return street + EOL_STRING + city + SPACE + postalCode + EOL_STRING;
}
}

abstract class PhoneNumber {
private String phoneNumber;
abstract String getCountryCode();

public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}

class USAddressFactory implements AddressFactory{
public Address createAddress(){
return new USAddress();
}

public PhoneNumber createPhoneNumber(){
return new USPhoneNumber();
}
}

class USAddress extends Address{
private static final String COUNTRY = "UNITED STATES";
private static final String COMMA = ",";

public String getCountry(){ return COUNTRY; }

public String getFullAddress(){
return getStreet() + EOL_STRING +
getCity() + COMMA + SPACE + getRegion() +
SPACE + getPostalCode() + EOL_STRING +
COUNTRY + EOL_STRING;
}
}

class USPhoneNumber extends PhoneNumber{
private static final String COUNTRY_CODE = "01";
private static final int NUMBER_LENGTH = 10;

public String getCountryCode(){ return COUNTRY_CODE; }

public void setPhoneNumber(String newNumber){
if (newNumber.length() == NUMBER_LENGTH){
super.setPhoneNumber(newNumber);
}
}
}

class FrenchAddressFactory implements AddressFactory{
public Address createAddress(){
return new FrenchAddress();
}

public PhoneNumber createPhoneNumber(){
return new FrenchPhoneNumber();
}
}

class FrenchAddress extends Address{
private static final String COUNTRY = "FRANCE";

public String getCountry(){ return COUNTRY; }

public String getFullAddress(){
return getStreet() + EOL_STRING + getPostalCode() + SPACE + getCity() + EOL_STRING + COUNTRY + EOL_STRING;
}
}

class FrenchPhoneNumber extends PhoneNumber{
private static final String COUNTRY_CODE = "33";
private static final int NUMBER_LENGTH = 9;

public String getCountryCode(){ return COUNTRY_CODE; }

public void setPhoneNumber(String newNumber){
if (newNumber.length() == NUMBER_LENGTH){
super.setPhoneNumber(newNumber);
}
}
}

public class AbstractFactoryPattern {

public static void main(String[] args) {
Address fd=new FrenchAddressFactory().createAddress();
System.out.println("French Address:" + fd.getFullAddress());
}
}
[/code]

This tutorial explain the basic concept of template method design pattern and how to use them. This is one of the pattern I have published as part of our Design pattern in Java series. If you are interested in receiving updates, please subscribe our newsletter.

What is Template Method Design Pattern?

An abstract class defines various methods and has one non-overridden method which calls the various methods.

also read:

• Design Pattern Interview Questions
• Factory Design Pattern
• State design pattern

Wikipedia Says:

A template method defines the program skeleton of an aligorithm.The aligorithm itself is made abstract,and the subclasses override the abstract methods to provide concrete behavior.First a class is created that provides the basic steps of an aligorithm design.These steps are implemented using abstract methods.Later on subclasses change the abstract methods to implement real actions.Thus the general aligorithm is saved in one place but the concrete steps may be changed by the subclasses.
Non-Abstract Methods are completly controlled by the Template Method.In contrast the template method need not be changed and is not an abstract operation and thus may guarentee required steps before and after the abstract operations.Thus the template method is invoked and as a consequence the non-abstract methods and abstract methods are called in the correct sequence.

Why Template Method?

Define the skeleton of an aligorithm in an operation,deferring some steps to subclasses.Template methods lets subclasses redefine certain steps of an aligorithm without changing the aligorithm structure .[DesignPatterns, p. 325]

Sometimes we want to specify the order of operations that a method uses,but allow sub-classes to provide their own implementation of some of these operations.When ever we see two methods in subclasses,it makes sense to bring the methods together into a superclass method.

When Template Method?

Use the Template method pattern:

• To implement the invariant parts of an algorithm once and leave it up to sub-classes to implement the behavior that can vary.
• To localize common behavior among subclasses and place it in a common class(in this case a superclass) to avoid code duplication.This is a classic example of “code refactoring”.
• To control how subclasses extend superclass operations.You can define a template method that calls “hook” operations at specific points,there by permitting extensions only at that point.

THE TEMPLATE METHOD IS A FUNDAMENTAL TECHNIQUE FOR CODE REUSE

Problem:
Two different component have significant similarities,but demonstrate no reuse of common interface or implementation.If a change common to both components becomes necessary,duplicate effort must be expended.

Discussion:
The component designer decides which steps of an aligorithm are invariant(or standard) and which are variant(or customizable).The invariant steps are implemented in an abstract base class,while the variant steps are either given a default implementation or no implementation at all.The “variant” steps represent “hooks”,or “placeholders” that can or must be supplied by the component’s client in a concrete derived class.
The component designer mandates the required steps of an aligorithm,and the ordering of the steps,but allow the component client to extend or replace some number of steps.
Template methods are prominently used in frameworks.Each framework implements the invariant pieces of domain’s architecture,and defines “placeholders” for all necessary or interesting client customization options.The inverted control structure has been affectionately labelled “the hollywood principle” – Don’t call us we will call you.

Usage:
The template method is used to:

• Let subclasses implement behavior that can vary.
• Avoid duplication in the code.We look for general code in the aligorithm and implement variants in the subclasses.
• Control at what point(s) subclassing is allowed.

Implementation Issues:

• Operations which must be overridden by subclasses should be made abstract.
• If the template method itself should not be overidden by subclasses it should be made final.
• To allow a subclass to insert code at a specific spot in the operation of the aligorithm,insert “hook” operations into the template method.These hook operations may do nothing by default.
• Try to minimize the number of operations that a subclass must override.
• In a template method parent class calls the operations of a subclass and not the other way round.

Example:
The template method defines a skeleton of an aligorithm in an operation and defers some steps to subclasses.Home Builders use the template method when developing a new subdivision.A typical subdivision consits of a limited number of floor plans with diff variations available for each.Within a floor plan, the foundation, framing, plumbing, and wiring will be identical for each house. Variation is introduced in the later stages of construction to produce a wider variety of models. [Michael Duell, “Non-software examples of software design patterns”, Object Magazine, Jul 97, p54]

Template method pattern could be refactored using an interface that explicitly signals the methods requested to subclasses and also the state needed by them from the abstract class.

Rules of Thumb:
Strategy is like Template Method except in its granularity.[Coplien, C++ Report, Mar 96, p88]
Template method uses inheritance to vary part of an aligorithm.Strategy uses delegation to vary the entire aligorithm. [GOF, p330]

Also Alex has a good explanation of why he hates Template Pattern.Even i do agree to some extent.

Below example gives an implementation of Template Design Pattern.

[code lang=”java”]
package patterns;

abstract class TitleInfo {
private String titleName;

// The Template Method.
// Calls the concrete class methods,is not overridden

public final String processTitleInfo() {
StringBuffer titleInfo=new StringBuffer();
titleInfo.append(this.getTitleBlurb());
titleInfo.append(this.getDvdEncodingRegionInfo());
return titleInfo.toString();
}

public final void setTitleName(String titleNameIn) {
this.titleName=titleNameIn;
}

public final String getTitleName() {
return this.titleName;
}

public abstract String getTitleBlurb();

public String getDvdEncodingRegionInfo() {
return " ";
}

}

class DvdTitleInfo extends TitleInfo {
String star;
char encodingRegion;

public DvdTitleInfo(String titleName,String star,char encodingRegion) {
this.setTitleName(titleName);
this.setStar(star);
this.setEncodingRegion(encodingRegion);
}

public char getEncodingRegion() {
return encodingRegion;
}

public void setEncodingRegion(char encodingRegion) {
this.encodingRegion = encodingRegion;
}

public String getStar() {
return star;
}

public void setStar(String star) {
this.star = star;
}

public String getTitleBlurb() {
return ("DVD: " + this.getTitleName() + ", starring " + this.getStar());
}

public String getDvdEncodingRegionInfo() {
return (", encoding region: " + this.getEncodingRegion());
}
}

class BookTitleInfo extends TitleInfo {
private String author;

public BookTitleInfo(String titleName,String author) {
this.setAuthor(author);
this.setTitleName(titleName);
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public String getTitleBlurb() {
return ("Book: " + this.getTitleName() + ", Author: " + this.getAuthor());
}
}

public class TemplatePatternDemo {

public static void main(String[] args) {
TitleInfo bladeRunner=new DvdTitleInfo("Blade Runner","Harrison Ford",’1′);
TitleInfo electricSheep=new BookTitleInfo("Do Androids Dream of Electric Sheep?","Philip");

System.out.println(" ");
System.out.println("Testing bladeRunner" + bladeRunner.processTitleInfo());
System.out.println("Testing electricSheep" + electricSheep.processTitleInfo());
}
}
[/code]