Builder

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• Think of builder pattern when you have a complex constructor or an object is built 

in multiple steps.
class Builder

Director -builder Builder

+ createPeroduct(): Product
+ build(): void
+ getProduct(): Product

ConcreteBuilder
Product
+ build(): void
+ getProduct(): Product

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Builder Client

Director (Role played by Client)

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Builder as inner class Client

(c)2018-19 Coffee Powered Crew

Example of a Builder Pattern
• The java.lang.StringBuilder class as well as various buffer classes in java.nio package like ByteBuffer, CharBuffer are 

often given as examples of builder pattern. 

• In my humble opinion they can be given as examples of builder pattern, but with an understanding that they don’t 

match 100% with GoF definition. These classes do allow us to build final object in steps, providing only a part of final 

object in one step. In this way they can be thought of as an implementation of builder pattern.

• So a StringBuilder satisfies the intent/purpose of builder pattern. However as soon we start looking at structure of 

the StringBuilder things start to fall apart. GoF definition also states that, builder has potential to build different 

representations of product interface using same steps.

(c)2018-19 Coffee Powered Crew

Example of a Builder Pattern
• There is another great example of builder pattern in Java 8. The java.util.Calendar.Builder class is a builder.

(c)2018-19 Coffee Powered Crew

Simple Factory

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Simple factory encapsulates away the object instantiation in a separate method.

• We can pass an argument to this method to indicate product type and/or additional arguments to help create objects

class SimpleFactory

Client «static»
Product
SimpleFactory

+ getProduct(String): Product

«implementationclass» «implementationclass»
ProductA ProductB

(c)2018-19 Coffee Powered Crew

Example of a Simple Factory
• The java.text.NumberFormat class has getInstance method, which is an example of simple factory.

(*Many examples advertised online as “Factory Method” are actually Simple Factories.)

(c)2018-19 Coffee Powered Crew

Factory Method

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Use factory method pattern when you want to delegate object instantiation to subclasses, you’d want to do this 
when you have “product” inheritance hierarchy  and possibility of future additions to that.
class FactoryMethod

Product Creator

ConcreteProductB ConcreteProductA ConcreteCreatorA ConcreteCreatorB

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Product

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Creator

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Client

(c)2018-19 Coffee Powered Crew

Examples of a Factory Method
• The java.util.Collection (or java.util.AbstractCollection) has an abstract method called iterator(). This method is an 

example of a factory method. 

• Remember, the most defining characteristic of factory method pattern is “subclasses providing the actual instance”. 

So static methods returning object instances are technically not GoF factory methods.

(c)2018-19 Coffee Powered Crew

Prototype

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Think of prototype pattern when you have an object where construction of a new instance is costly or 

not possible (object is supplied to your code).

• In Java we typically implement this pattern with clone method.

• Objects which have a majority of their state as immutable are good candidates for prototypes.

• When implementing clone method pay attention to the requirement of deep or shallow copy of object 

state.

• Also we’ve to insure that clone is “initialized”; that is appropriate states are reset before returning the 

copy to outside world.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Prototype

«abstract»
Client Prototype
+ clone(): Prototype

ConcretePrototypeA ConcretePrototypeB
+ clone(): ConcretePrototypeA + clone(): ConcretePrototypeB

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Prototype

(c)2018-19 Coffee Powered Crew

Example of a Prototype

• Actually the Object.clone() method is an example of a prototype! 

• This method is provided by Java and can clone an existing object, thus allowing any object to act as 

a prototype. Classes still need to be Cloneable but the method does the job of cloning object.

• We also use the same method to implement our own prototype, as it is a well known method and 

has same meaning as we want in a prototype method.

(c)2018-19 Coffee Powered Crew

Abstract Factory

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• When you have multiple sets of objects where objects in one set work together then you can use 

abstract factory pattern to isolate client code from concrete objects & their factories.

• Abstract factory itself uses factory method pattern and you can think of them as objects with 

multiple factory methods.

• Adding a new product type needs changes to base factory and all its implementations.

• Concrete factories can be singleton as we need only one instance of them in code.

• We provide client code with concrete factory instance. Factories can be changed at runtime.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class AbstractFactoryEx_cloud

Client
«abstractfactory»
ResourceFactory

+ createInstance(capacity): Instance
«abstract_product»
+ createStorage(inMib): Storage
Instance

+ start(): void
+ stop(): void
+ attachStorage(storage): void

«concrete_product»
«concrete_product»
Ec2Instance
GoogleComputeEngineInstance

«concrete_factory»
GoogleCloudResourceFactory «concrete_factory»
AwsResourceFactory «abstract_produ...
+ createInstance(capacity): Instance Storage
+ createStorage(inMib): Storage + createInstance(capacity): Instance
+ createStorage(inMib): Storage
+ getId(): String

«concrete_product» «concrete_product»
S3Storage GoogleCloudStorage

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Abstract Products

“Amazon Web Services” Product Family “Google Cloud Platform” Product Family

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Abstract Factory Client

Implementations of Abstract Factory

(c)2018-19 Coffee Powered Crew

Example of an Abstract Factory
• The javax. xml.parsers.DocumentBuilderFactory is a good example of an abstract factory pattern. 

• However this implementation doesn’t match 100% with the UML of abstract factory from GoF. The class has a static

newInstance() method which returns actual factory class object.

• The newInstance() method however uses classpath scanning, system properties, an external property file as ways to 

find the factory class & creates the factory object. So we can change the factory class being used, even if this is a 

static method. 

• Another great example is the java.util.prefs.PreferencesFactory interface which matches more closely with the UML 

we studied.

(c)2018-19 Coffee Powered Crew

Singleton

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Singleton pattern is used when you want to ensure that only one instance of a class exists in application.

• In Java we achieve this by making constructor private, this also prevents inheritance & providing a public static 

method which returns the singleton instance

• Implementation wise we have two broad choices –

1. In eager loading singleton, we create instance as soon as class is loaded by classloader. 

2. In lazy loading singleton, we defer creation until some code actually requests the instance.

• Always prefer the eager loading instance unless creation cost is high and start‐up time impact is noticeable.

(c)2018-19 Coffee Powered Crew

• Eager Singleton

(c)2018-19 Coffee Powered Crew

• Lazy Singleton with Double check Locking

(c)2018-19 Coffee Powered Crew

• Lazy Singleton with Initialization Holder

(c)2018-19 Coffee Powered Crew

• Singleton as enum

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• There are very few situations where a Singleton is really a good choice. 

• Application configuration values can be tracked in a singleton. Typically these 

are read from file at start and then referred to by other parts of application.

• Logging frameworks also make use of Singleton pattern. 

• Spring framework treats all beans by default as singletons. In spring we don’t 

have to make any changes to ensure single instance, Spring handles that for us.

(c)2018-19 Coffee Powered Crew

Example of a Singleton Pattern

• The java.lang.Runtime class in standard Java API is a singleton.

(c)2018-19 Coffee Powered Crew

Object Pool

Creational Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• If cost of creating instances of a class is very high and you need many such objects throughout your application for short duration then you can pool 

them with object pool.

• Typically objects that represent fixed external system resources like threads, connections or other system resources are good candidates for pooling
class ObjectPool

«use»

ObjectPool AbstractReusable
Client + getReusable() + operation()
+ releaseReusable()

ConcreteReusable
- state
+ operation()
+ reset()

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Objects to be pooled should provide a method to “reset” their state so they can be reused. This operation should be efficient as

well, otherwise release operation will be costly.

• Pool must handle synchronization issues efficiently and reset object state before adding them to pool for reuse.

• Client code must release pooled objects back into the pool so they can be reused. Failing to do so will break the system. Thread

pools can work around this since the a thread can know when its work is done.

• Difficult to optimize as pools are sensitive to system load at runtime (demand of pooled objects). 

• Pools are good choice when the pooled objects represent a fixed quantity of externally available resource like thread or a 

connection.

• If you create objects when pool is empty then we have to make sure that pool size is maintained or else we can end up with large

pool

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Poolable Concrete Reusable

Reusable Product

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Object Pool Client

(c)2018-19 Coffee Powered Crew

 Examples of object pool
• Using object pool for saving the memory allocation & GC cost is almost deprecated now. JVMs & hardware are more 

efficient & have access to more memory now. 

• However it is still a very common pattern when we are interacting with external resources like threads, connections.

• java.util.concurrent.ThreadPoolExecutor is an example of object pool pattern which pools threads. Even though we can 

directly use this class, you’ll often use it via ExecutorService interface using method like Executors like 

newCachedThreadPool(). 

(c)2018-19 Coffee Powered Crew

 Examples of object pool
• Apache commons dbcp library is used for database connection pooling. Class org.apache.commons.dbcp.BasicDataSource in 

dbcp package is an example of object pool pattern which pools database connections. This pool is commonly created 

and exposed via JNDI or as a Spring bean in applications.

(c)2018-19 Coffee Powered Crew

Adapter (aka Wrapper)

Structural Design Patterns

Design Patterns in Java

In-A-Hurry Summary

• We have an existing object with required functionality but the client code is expecting a

different interface than our object.

• A class adapter is one where adapter inherits from class of object which is to be adapted and

implements the interface required by client code. This adapter type should be avoided.

• An object adapter uses composition over inheritance. It’ll implement the target interface and

use an adaptee object composition to perform translation. This allows us to use subclasses of

adaptee in adapter.
 In-A-Hurry Summary
class Adapter

Class Adapter

«interface» Adaptee
Client Target
+ myOperation(): void
+ operation(): void

class AdapterObject

Adapter
operation
Object Adapter
+ operation(): void
this.myOperation()

«interface»
Target
Client Adaptee
«use» + operation(): void
+ myOperation(): void

#adaptee
ObjectAdapter

+ operation(): void
operation
adaptee.myOperation()
In-A-Hurry Summary
Target Interface Our existing class (Adaptee)

Client Code expecting the target interface

In-A-Hurry Summary
Class Adapter Using Class Adapter

• Here we end up with an object that has publicly

available methods from both Adaptee and Target
interface.
• Avoid class adapters!
In-A-Hurry Summary
Object Adapter Using Object Adapter
Example of an Adapter
• The java.io.InputStreamReader and java.io.OutputStreamWriter classes are examples of object adapters.

• These classes adapt existing InputStream/OutputStream object to a Reader/Writer interface. 

(c)2018-19 Coffee Powered Crew

Bridge

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• We use bridge pattern when we want our abstractions and implementations to be 

decoupled.

• Bridge pattern defines separate inheritance hierarchies for abstraction & implementations 

and bridge these two together using composition.

• Implementations do not HAVE to define methods that match up with methods in abstraction. 

It is fairly common to have primitive methods; methods which do small work; in 

implementor. Abstraction uses these methods to provide its functionality.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Bridge

«abstract» Implementor
Client Abstraction
«use» + step1(): void
+ operation(): void + step2(): void

RefinedAbstraction
ConcreteImplementorA ConcreteImplementorB
+ step1(): void + step1(): void
+ step2(): void + step2(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Abstraction Implementor

Refined Abstraction Concrete Implementor

(c)2018-19 Coffee Powered Crew

Example of a Bridge
• An example of bridge pattern is the SLF4J logging framework. Using slf4j we can switch the actual logging framework being used by 

dropping jar files in classpath. The client code using slf4j API remains unaffected. So the abstraction (slf4j API) can vary independent 

of implementation (log4j, logback etc)

(c)2018-19 Coffee Powered Crew

Example of a Bridge
• An example of bridge pattern often given is the JDBC API. More specifically the java.sql.DriverManager class with the 

java.sql.Driver interface form a bridge pattern.

class JDBC

DriverManager «interface»
Driver
+ getConnection() «bridge»
+ connect()

oracle.jdbc.driver.OracleDriver
com.mysql.jdbc.Driver
+ connect()
+ connect()

(c)2018-19 Coffee Powered Crew

Example of a Bridge
• An example of bridge pattern often given is the Collections.newSetFromMap() method. This method returns a Set which is backed by 

given map object.

(c)2018-19 Coffee Powered Crew

Decorator

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• We use decorator when we want to add small behaviour on top of existing object.

• A decorator has same interface as the object it decorates or contains.

• Decorators allow you to dynamically construct behaviour by using composition. A decorator can wrap 

another decorator which in turn wraps original object.

• Client of object is unaware of existence of decorator. 

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Decorator

Component

+ operation(): void

-comp
ConcreteComponent Decorator operation
comp.operation()
+ operation(): void + operation(): void addedBehavior()
# addedBehavior(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Component Decorator

Concrete Component

Client

(c)2018-19 Coffee Powered Crew

Example of a Decorator
• Classes in Java’s I/O package are great examples of decorator pattern.

• For example the java.io.BufferedOutputStream class decorates any java.io.OutputStream object and adds buffering to file writing
operation. This improves the disk i/o performance by reducing number of writes.
class java_io

«abstract_component»
OutputStream

«concrete_component» «decorator»
FileOutputStream FilterOutputStream

«decorator»
BufferedOutputStream
Composite

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• We have a parent‐child or whole‐part relation between objects. We can use composite pattern to 

simplify dealing with such object arrangements.

• Goal of composite pattern is to simplify the client code by allowing it to treat the composites and leaf 

nodes in same way.

• Composites will delegate the operations to its children while leaf nodes implement the functionality.

• You have to decide which methods the base component will define. Adding all methods here will allow 

client to treat all nodes same. But it may force classes to implement behaviour which they don’t have.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Composite

Component
Client
«use»
+ operation(): void
+ add(Component): void
+ remove(Component): void

Leaf Composite

+ operation(): void + operation(): void

+ add(Component): void -children
+ remove(Component): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Component Composite

Leaf Node

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Client of composite pattern

(c)2018-19 Coffee Powered Crew

 Example of a Composite
• Composite is used in many UI frameworks, since it easily allows to represent a tree of UI controls.

• In JSF we have UIViewRoot class which acts as composite. Other UIComponent implementations like UIOutput, UIMessage act as leaf 

nodes. 
class JSF

«interface»
UIComponent

UIComponentBase
+ getChildren()
+ getChildCount()

«leaf» «leaf» «composite»

UIMessage UIOutput UIViewRoot
+ getChildren() + getChildren() + getChildren()
+ getChildCount() + getChildCount() + getChildCount()

(c)2018-19 Coffee Powered Crew

Facade

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• We use façade when using our subsystem requires dealing with lots of classes & interfaces 

for client. Using façade we provide a simple interface which provides same functionality.

• Façade is not a simple method forwarding but façade methods encapsulate the subsystem 

class interactions which otherwise would have been done by client code.

• Facades are often added over existing legacy codes to simplify code usage & reduce coupling 

of client code to legacy code. 

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class Facade

Facade

+ operation(): void

Subsystem

Package3

Package1

Package2
Class5
Class2 Class3
+ op3(): void
+ op1(): void Class1 Class4

+ op2(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Facade

(c)2018-19 Coffee Powered Crew

Example of a Facade
• The java.net.URL class is a great example of façade. This class provides a simple method called as openStream() and we get an 
input stream to the resource pointed at by the URL object. 

• This class takes care of dealing with multiple classes from the java.net package as well as some internal sun packages.
class URL

Client

java.net

URL.class
«facade»
URLStreamHandler
URL

+ openStream()

URLStreamHandlerFactory
+ createURLStreamHandler()

sun.net.www.protocol

file.Handler ftp.Handler http.Handler

(c)2018-19 Coffee Powered Crew

Flyweight

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• We use flyweight design pattern if we need large number of objects of class where we can 

easily separate out state that can be shared and state that can be externalized.

• Flyweights store only “intrinsic” state or state that can be shared in any context.

• Code using flyweight instance provides the extrinsic state when calling methods on flyweight. 

Flyweight object then uses this state along with its inner state to carry out the work.

• Client code can store extrinsic per flyweight instance it uses or compute it on the fly. 

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Flyweight

FlyweightFactory Flyweight
+ getFlyweight(key): Flyweight + operation(extrinsicState): void

ConcreteFlyweight UnsharedConcreteFlyweight
Client - intrinsicState - allState
«use»
+ operation(extrinsicState): void + operation(extrinsicState): void

«use»

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Flyweight Unshared Flyweight

Concrete Flyweight

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Flyweight Factory Client

(c)2018-19 Coffee Powered Crew

Examples of a Flyweight
• Java uses flyweight pattern for Wrapper classes like java.lang.Integer, Short, Byte etc. Here the valueOf

static method serves as the factory method.

• String pool which is maintained by JVM is also an example of flyweight. We can call the intern() method 

on a String object to explicitly request this String object to be interned. This method will returned a 

reference to already cached object if present or else will create new String in cache if not present.

Note:‐ String.intern() is a native method.

(c)2018-19 Coffee Powered Crew

Proxy

Structural Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• We want a stand in or placeholder object or we want control access to our objects method, then we can use proxy 

pattern.

• Proxy implements same interface as expected of real object. It delegates actual functionality to real object. Proxies are 

either given real object or they create one when needed. Some proxies talk to remote service behind the scene.

• Main usage of proxies is for:

• Protection Proxy ‐ Control access to original object’s operations

• Remote Proxy – Provides a local representation of a remote object. 

• Virtual proxy – Delays construction of original object until absolutely necessary

• In java we can also use dynamic proxies. These are created on the fly at runtime. 

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Proxy

«interface»
Subject
Client + operation(): void

RealSubject Proxy
+ operation(): void + operation(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Subject Interface Proxy

Concrete Subject

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Image Factory Client

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Image Invocation Handler Image Factory

Client

(c)2018-19 Coffee Powered Crew

Examples of a Proxy
• This is one pattern where you’ll find numerous examples 

• Hibernate uses a proxy to load collections of value types. If you have a relationship in entity class mapped as a 

collection, marked as candidate for lazy loading then Hibernate will provide a virtual proxy in its place.

• Spring uses proxy pattern to provide support for features like transactions, caching and general AOP support.

• Hibernate & spring both can create proxies for classes which do not implement any interface. They use third party 

frameworks like cglib, aspectJ to create dynamic proxies (remember, Java’s dynamic proxy needs interface) at 

runtime.

(c)2018-19 Coffee Powered Crew

Chain of Responsibility

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• When we want to decouple sender of request from the object which handles the request, we use 

chain of responsibility.

• We want this decoupling because we want to give multiple objects chance to handle the request & we 

don’t know all objects before hand.

• A handler checks if it can handle the request. If it can’t then it’ll pass the request on to next handler in 

chain.

• You can pass the request down the chain even if a handler handles the request. Design pattern 

doesn’t prevent that from happening.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class ChainOfResponsibility

+successor

Handler
Client
+ handleRequest(): void
«use»

ConcreteHandlerA ConcreteHandlerB
+ handleRequest(): void + handleRequest(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Handler Abstract Handler

Concrete Handler

Setup chain of responsibility

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Request Client

(c)2018-19 Coffee Powered Crew

Example of a Chain of responsibility
• Probably the best example of chain of responsibility is servlet filters. Each filter gets a chance to handle 

incoming request and passes it down the chain once its work is done.

• All servlet filters implement the javax.servlet.Filter interface which defines following doFilter method 

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 

• Implementations will use FilterChain object to pass request to next handler in chain

i.e. chain.doFilter(request, response);

• In servlet filters, it’s common practice to allow other filters to handle request even if current filter takes

some action on the request.

(c)2018-19 Coffee Powered Crew

Command

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• Command pattern allows you to treat requests for operations as objects. This allows you to send these 

objects to different parts of code for later execution or to a different thread.

• Commands typically invoke the actual operation on a receiver but contain parameters or information 

needed for invocation.

• Client code is responsible for creating instances of command & providing it with receiver and request 

information.

• Commands can also implement an undo feature. Here command itself stores a snapshot of receiver.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class Command

Client «abstract»
Invoker
Command
+ execute(): void

Receiver
ConcreteCommand
+ operation(): void
- state
+ execute(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Command Concrete Command

Receiver

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Invoker Client

(c)2018-19 Coffee Powered Crew

Example of Command Pattern
• The java.lang.Runnable interface represents the Command pattern.

• We create the object of class implementing runnable, providing all information it needs.

• In the run method we’ll call an operation on the receiver.

• We can send this object for later execution to other parts of our application.

• The Action class in struts framework is also an example of Command pattern. Here each URL is mapped to 

a action class. We also configure the exact no‐arg method in that class which is called to process that 

request.

(c)2018-19 Coffee Powered Crew

Interpreter

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• When we want to parse a language with rules we can use the interpreter pattern.

• Each rule in the language becomes an expression class in the interpreter pattern. A terminal 

expression provides implementation of interpret method. A non‐terminal expression holds other 

expressions and calls interpret on its children.

• This pattern doesn’t provide any solution for actual parsing and building of the abstract syntax tree. 

We have to do it outside this pattern.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class Interpreter

Context

AbstractExpression
Client
+ interpret(context)

TermialExpression NonTerminalExpression
+ interpret(context) + interpret(context)

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Abstract Expression Non‐terminal Expression

Terminal Expression

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Expression Builder Client

(c)2018-19 Coffee Powered Crew

Examples of Interpreter
• The java.util.regex.Pattern class is an example of interpreter pattern in Java class library.

• Pattern instance is created with an internal abstract syntax tree, representing the grammar rules, during the static 
method call compile(). After that we check a sentence against this grammar using Matcher.

• Classes supporting the Unified Expression Language (EL) in JSP 2.1  JSF 1.2. These classes are in javax.el package. We 
have javax.el.Expression as a base class for value or method based expressions. We have javax.el.ExpressionFactory
implementations to create the expressions. javax.el.ELResolver and its child classes complete the interpreter 
implementation.  

(c)2018-19 Coffee Powered Crew

Mediator

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

• When we want to decouple a group of objects which communicate with each other then we 

can use the mediator design pattern.

• Each object only knows about the mediator object and notifies it about change in it’s state. 

Mediator in turn will notify other objects on its behalf.

• Mediators are typically specific to a collaboration. It’s difficult to write a reusable mediator. 

Observer design pattern solves this problem. However mediators are easy to implement and 

extend.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Mediator

Mediator #mediator Colleague

changed
+ collegueChanged(collegue) # changed() mediator.collegueChanged(this)

ConcreteMediator
ConcreteColleagureA
+ collegueChanged(collegue) ConcreteColleagueB
+ setAValue(val)
+ setBValue(val)

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Mediator Concrete Colleague

Colleague

(c)2018-19 Coffee Powered Crew

Examples of Mediator
• Sometimes a front controller is given as an example of mediator pattern. E.g. The DispatcherServlet in Spring.

• Purpose of front controller is to act as a central point where requests from outside world can land and then they are forwarded to 
appropriate page controller, often by use of some form of URL to class mapping.

• Front controller pattern can be thought of as a specialized version of mediator pattern. Front controller satisfies mediator characteristics like 
acting as central hub for communication between objects. It is specialized since it also handles requests from outside system & performs 
lookup to find a specific controller which will handle the request. In mediator when one object changes all others are notified! 

(c)2018-19 Coffee Powered Crew

Iterator

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• When we want to iterate or give sequential access to elements of aggregate object we can use iterator 

design pattern.

• Iterator needs access to internal data structure of aggregator to provide its functionality. This usually 

means it’s quite common to have iterator implemented as inner class.

• Iterator allows the client code to check whether there is an element available to consume and give 

next available element.

• We can also provide reverse, or bi‐directional (forward + backward) iterator depending on underlying 

data structure.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Iterator

Aggregate
Client Iterator
+ createIterator()
+ next()
+ hasNext()

ConcreteAggregate ConcreteIterator
+ createIterator() + next()
+ hasNext()

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Iterator Concrete Iterator

Aggregate
Client

(c)2018-19 Coffee Powered Crew

Examples of Iterator
• Yup! The iterator classes in Java’s collection framework are great examples of iterator.  The concrete 

iterators are typically inner classes in each collection class implementing java.util.Iterator interface.

• The java.util.Scanner class is also an example of Iterator pattern. This class supports InputStream as well 

and allows to iterate over a stream.

• The javax.xml.stream.XMLEventReader class is also an iterator. This class turns the XML into a stream of 

event objects.

(c)2018-19 Coffee Powered Crew

Memento

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• We can use memento design pattern to take a snapshot of object’s state which can be then used to restore 

object to that particular state.

• Memento itself is created such that it doesn’t expose any state stored in it to any other class aside from the 

originator.

• Originator provides a method to get a memento out of it. And another method to assign it a memento, 

which results in getting the originator’s state reset to the one in memento.

• Mementos need to be saved for them to be of any use. Originator can save them but it adds complexity.

• Memento works well with command pattern. Each commands saves a memento as part of execution.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Memento

Originator Memento
- state - state CareTaker
+ setMemento(memento) - getState()
+ createMemento() - setState(state)

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Memento Originator

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Caretaker

(c)2018-19 Coffee Powered Crew

Example of a Memento
• One great example of memento is the undo support provided by the  javax.swing.text.JTextComponent and its child 
classes like JTextField, JTextArea etc.

• The javax.swing.undo.UndoManager acts as the caretaker & implementations of javax.swing.undo.UndoableEdit
interface work as mementos. The javax.swing.text.Document implementation which is model for text components in 
swing  is the originator.

• The java.io.Serializable is often given as an example of Memento but it is NOT a memento & not even a design pattern. 
Memento object itself can be serialized but it is NOT mandatory requirement of the pattern. In fact mementos work 
most of the times with in‐memory snapshots of state.

(c)2018-19 Coffee Powered Crew

Observer

Behavioral Design Patterns

Design Patterns in Java
In‐A‐Hurry Summary
• Observer pattern allows to define one‐to‐many dependency between objects where many objects are interested in state 

change of a object.

• Observers register themselves with the subject which then notifies all registered observers if any state change occurs.

• In the notification sent to observers it is common to only send reference of subject instead of state values. Observers will 

call the subject back for more information if needed.

• We can also register observers for a specific event only, resulting in improved performance of sending notifications in the 

subject.

• This design pattern is also known as publisher‐subscriber pattern. Java messaging uses this pattern but instead of registering 

with subject, listeners register with a JMS broker, which acts as a middleman. 
In‐A‐Hurry Summary
class Observer

«interface» «interface»
Subject Observer

+ attach(observer) + updated(subject)
+ detach(observer)
+ notify()

ConcreteSubject
- state1 ConcreteObserver
- state2
+ updated(subject)
+ attach(observer)
+ detach(observer)
+ notify()
+ getState(name)
In-A-Hurry Summary
Subject Observer

Concrete Observer

Attaching Observers to Subject

Examples of Observer
• Observer is such a useful pattern that Java comes with support for this support in Java Class Library! We have 

java.util.Observer interface & java.util.Observable class shipped with JDK.

Although for some reason I haven’t seen developers using these outside of Swing. 

• Another commonly used example is various listeners in Java Servlet  application. We can create various listeners 

by implementing interfaces like HttpSessionListener, ServletRequestListener. 

• We then register these listeners with ServletContext’s addListener method. These listeners are notified when 

certain events occur like, creation of a request or addition of a value to the session.

• The notification will sent to observers based on the event that has taken place and the interface(s) 

implemented by registered observers.

• Spring also supports Observer through the org.springframework.context.ApplicationListener interface.

(c)2018-19 Coffee Powered Crew

State

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• If we have an object whose behavior is completely tied to its internal state which can be expressed as an 

object we can use the state pattern.

• Each possible state value now becomes a class providing behavior specific to a state value.

• Our main object (aka context) delegates the actual operation to its current state. States will implement 

behavior which is specific to a particular state value.

• Context object’s state change is explicit now, since we change the entire state object.

• State transitions are handled either by states themselves or context can trigger them.

• We can reuse state objects if they don’t have any instance variables and only provide behavior.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class State

Context -state «interface»

State
+ operation()
+ handleOperation()

ConcreteStateA ConcreteStateB

+ handleOperation() + handleOperation()

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
State Context

Concrete State

(c)2018-19 Coffee Powered Crew

Examples of State pattern
• One of the examples of state pattern can be found in JSF(Java Server Faces) framework’s LifeCycle
implementation.

• FacesServlet will invoke execute & render methods of LifeCycle. LifeCycle instance in turn collaborates 

with multiple “phases” to execute a JSF request. Here each phase represents a state in state pattern. 

• JSF has six phases: RestoreViewPhase, ApplyRequestValues, ProcessValidationsPhase, 
UpdateModelValuesPhase, InvokeApplicationPhase, and RenderResponsePhase

• The LifeCycle also provides an object of FacesContext to these phases to help in providing state specific 

behavior.

• In case you are not familiar with JSF, then you can always fall back on the order processing example that 
we studied.

(c)2018-19 Coffee Powered Crew

Strategy

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Strategy pattern allows us to encapsulate algorithms in separate classes. The class using these algorithms 

(called context) can now be configured with desired implementation of an algorithm.

• It is typically the responsibility of client code which is using our context object to configure it.

• Strategy objects are given all data they need by the context object. We can pass data either in form of 

arguments or pass on context object itself. 

• Strategy objects typically end up being stateless making them great candidates for flyweight pattern.

• Client code ends up knowing about all implementations of strategy since it has to create their objects.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class Strategy

Context «interface»
-strategy Strategy
+ operation(): void
+ runAlgorithm(): void

ConcreteStrategyA ConcreteStrategyB
+ runAlgorithm(): void + runAlgorithm(): void

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Strategy Concrete Strategy

Context

Concrete Strategy

(c)2018-19 Coffee Powered Crew

Examples of Strategy pattern
• The java.util.Comparator is a great example of strategy pattern. We can create multiple implementations 

of comparator, each using a different algorithm to perform comparison and supply those to various sort 

methods.

(c)2018-19 Coffee Powered Crew

Examples of Strategy pattern

• Another example of strategy pattern is the ImplicitNamingStrategy & PhysicalNamingStrategy contracts in 

Hibernate. Implementations of these classes are used when mapping an Entity to database tables. These 

classes tell hibernate which table to use & which columns to use. 

• We can use different algorithms to perform mapping from domain model mapping to a logical name via 

ImplicitNamingStrategy & then from logical name to physical name via PhysicalNamingStrategy.

(c)2018-19 Coffee Powered Crew

Template Method

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Template method allow us to define a skeleton of an algorithm in base class. Steps of algorithm are 

defined as abstract methods in base class. 

• Subclasses of our abstract class will provide implementation of steps. This way we can have different 

implementations for same algorithm.

• Client will create object of any of the concrete subclasses and use the algorithm.

• Factory method design pattern is often implemented as part of template method design pattern.

• One drawback of template method is algorithm implementation is now spread across multiple classes so 

it makes it slightly difficult to understand.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class TemplateMethod

AbstractClass
+ templateMethod()
+ step1()
+ step2()
+ step3()

ConcreteClassA
ConcreteClassB
+ step1()
+ step2() + step1()
+ step3() + step2()
+ step3()

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Abstract Class Concrete Class

(c)2018-19 Coffee Powered Crew

Examples of Template Method
• The java.util.AbstractMap, java.util.AbstractSet classes have many non‐abstract methods that are good 

exampels of template method pattern. 

(c)2018-19 Coffee Powered Crew

Visitor

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Visitor pattern allows to add new operations that work on objects without modifying class definitions of these 

objects. 

• Visitors define class specific methods which work with an object of that class to provide new functionality. 

• To use this pattern classes define a simple accept method which gets a reference to a visitor and inside this 

method, objects class method on visitor which is defined for that specific class.

• Adding a new functionality means creating a new visitor and implementing new functionality in that class 

instead of modifying each class where this functionality is needed.

• This pattern is often used where we have an object structure and then another class or visitor itself iterates 

over this structure passing our visitor object to each object.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
class Visitor

«interface»
Visitor
Client
+ visitConcreteElementA(concreteElementA)
+ visitConcreteElementB(concreteElementB)

ConcreteVisitorB
ConcreteVisitorA
+ visitConcreteElementA(concreteElementA)
+ visitConcreteElementA(concreteElementA) + visitConcreteElementB(concreteElementB)
+ visitConcreteElementB(concreteElementB)

Role:- Element
- Defines accept operation
«interface»
ObjectStructure Element

+ accept(visitor)

ConcreteElementA ConcreteElementB

+ accept(visitor) + accept(visitor)
+ operationA() + operationB()

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Element Interface Concrete Elements

Abstract Element

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Visitor Concrete Visitor

(c)2018-19 Coffee Powered Crew

Examples of Visitor Pattern
• The dom4j library used for parsing XML has interface  org.dom4j.Visitor & implementation org.dom4j.VisitorSupport 
which are examples of visitor. By implementing this visitor we can process each node in an XML tree.

• Another example of visitor pattern is the java.nio.file.FileVisitor & its implementation SimpleFileVisitor.

(c)2018-19 Coffee Powered Crew

Null Object

Behavioral Design Patterns

Design Patterns in Java

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
• Null object pattern allows us to represent absence of real object as a do nothing object. 

• Method implementations in a Null object will not do anything. In case a return value is expected, these 

methods will return a sensible, hard‐coded default value.

• Classes which use Null object won’t be aware of presence of this special implementation. Whole purpose 

of the pattern is to avoid null checks in other classes.

• Null objects do not transform into real objects, nor do they use indirection to real objects.

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary

class NullObject

AbstractClass
Client
«use» + operation(): void

ConcreteClass NullClass
+ operation(): void + operation(): void operation
//do nothing

(c)2018-19 Coffee Powered Crew

In‐A‐Hurry Summary
Base Class Null Object

(c)2018-19 Coffee Powered Crew

Example of Null Object
• The various adapter classes from java.awt.event package can be thought of as examples null object. Only reason 

they are not the examples of this pattern is that they are abstract classes but without any abstract method.

(c)2018-19 Coffee Powered Crew