Builder Design pattern in Java - Example Tutorial

Builder design pattern in Java is a creational pattern i.e. used to create objects, similar to factory method
design pattern which is also creational design pattern. Before learning any design pattern I suggest find out
the problem a particular design pattern solves. Its been well said necessity is mother on invention.
Learning design pattern without facing problem is not that effective, Instead if you have already faced issues
than its much easier to understand design pattern and learn how its solve the issue. In this Java
design pattern tutorial we will first see what problem Builder design pattern solves which will give
some insight on when to use builder design pattern in Java, which is also a popular design pattern
interview question and then we will see example of Builder design pattern and pros and cons of using
Builder pattern in Java.

What problem Builder pattern solves in Java

As I said earlier Builder pattern is a creational design pattern it means its solves problem related to object
creation. Constructors in Java are used to create object and can take parameters required to create object.
Problem starts when an Object can be created with lot of parameters, some of them may
be mandatory and others may be optional. Consider a class which is used to create Cake, now you need
number of item like egg, milk, flour to create cake. many of them are mandatory and some of them are
optional like cherry, fruits etc. If we are going to have overloaded constructor for different kind of cake
then there will be many constructor and even worst they will accept many parameter.
Problems:
1) Too many constructors to maintain.
2) error prone because many fields has same type e.g. sugar and and butter are in cups so instead of 2
cup sugar if you pass 2 cup butter, your compiler will not complain but will get a buttery cake with almost no
sugar with high cost of wasting butter.
You can partially solve this problem by creating Cake and then adding ingredients but that will impose
another problem of leaving Object on inconsistent state during building, ideally cake should not be
available until its created. Both of these problems can be solved by using Builder design pattern in
Java. Builder design pattern not only improves readability but also reduces chance of error by adding
ingredients explicitly and making object available once fully constructed.

Example of Builder Design pattern in Java

We will use same example of creating Cake using Builder design pattern in Java. Here we have static
nested builder class inside Cake which is used to create object.
Guidelines for Builder design pattern in Java
1) Make a static nested class called Builder inside the class whose object will be build by Builder. In this
example its Cake.
2) Builder class will have exactly same set of fields as original class.
3) Builder class will expose method for adding ingredients e.g. sugar() in this example. Each method will
return same Builder object. Builder will be enriched with each method call.
4) Builder.build() method will copy all builder field values into actual class and return object
of Item class.
5) Item class (class for which we are creating Builder) should have private constructor to create its object
from build() method and prevent outsider to access its constructor.

public class BuilderPatternExample {

public static void main(String args[]) {
//Creating object using Builder pattern in java
Cake whiteCake
= new Cake.Builder().sugar(1).butter(0.5). eggs(2).vanila(2).flour(1.5). baking
powder(0.75).milk(0.5).build();
//Cake is ready to eat :)
System.out.println(whiteCake);
}
}
class Cake {
private
private
private
private
private
private
private
private

final
final
final
final
final
final
final
final

double sugar;
//cup
double butter; //cup
int eggs;
int vanila;
//spoon
double flour;
//cup
double bakingpowder; //spoon
double milk; //cup
int cherry;

public static class Builder {

private
private
private
private
private
private
private
private

double sugar;
//cup
double butter; //cup
int eggs;
int vanila;
//spoon
double flour;
//cup
double bakingpowder; //spoon
double milk; //cup
int cherry;

//builder methods for setting property

public Builder sugar(double cup){this.sugar = cup; return this; }
public Builder butter(double cup){this.butter = cup; return this; }
public Builder eggs(int number){this.eggs = number; return this; }
public Builder vanila(int spoon){this.vanila = spoon; return this; }
public Builder flour(double cup){this.flour = cup; return this; }
public Builder bakingpowder(double spoon){this.sugar =
spoon; return this; }
public Builder milk(double cup){this.milk = cup; return this; }
public Builder cherry(int number){this.cherry = number; return this; }
//return fully build object
public Cake build() {
return new Cake(this);
}
}
//private constructor to enforce object creation through builder
private Cake(Builder builder) {
this.sugar = builder.sugar;
this.butter = builder.butter;
this.eggs = builder.eggs;
this.vanila = builder.vanila;
this.flour = builder.flour;
this.bakingpowder = builder.bakingpowder;
this.milk = builder.milk;

this.cherry = builder.cherry;
}
@Override
public String toString() {
return "Cake{" + "sugar=" + sugar + ", butter=" + butter + ", eggs=" +
eggs + ", vanila=" + vanila + ", flour=" + flour + ", bakingpowder=" +
bakingpowder + ", milk=" + milk + ", cherry=" + cherry + '}';
}
}
Output:
Cake{sugar=0.75, butter=0.5, eggs=2, vanila=2, flour=1.5, bakingpowder=0.0,
milk=0.5, cherry=0}

Builder design pattern in Java Pros and Cons

Like everything Builder pattern also has some disadvantages, but if you look at below, advantages clearly
outnumber disadvantages of Builder design pattern. Any way here are few advantages and disadvantage
of Builder design pattern for creating objects in Java.
Advantages:
1) More maintainable if number of fields required to create object is more than 4 or 5.
2) Less error-prone as user will know what they are passing because of explicit method call.
3) More robust as only fully constructed object will be available to client.
Disadvantages:
1) Verbose and code duplication as Builder needs to copy all fields from Original or Item class.

When to use Builder Design pattern in Java

Builder Design pattern is a creational pattern and should be used when number of parameter required
in constructor is more than manageable usually 4 or at most 5. Don't confuse with Builder and
Factory pattern there is an obvious difference between Builder and Factory pattern, as Factory can be used
to create different implementation of same interface but Builder is tied up with its Container class and only
returns object of Outer class.

Decorator design Pattern in Java with Example Java Tutorial

I was thinking to write on decorator design pattern in Java when I first wrote 10 interview
questions on Singleton Pattern in Java. Since design pattern is quite important while building
software and its equally important on any Core Java Interview, Its always good to have clear
understanding of various design patterns in Java. In this article we will explore and
learn Decorator Design pattern in Java which is a prominent core Java design pattern and
you can see lot of its example in JDK itself. JDK use decorator pattern in IO package where it
has decorated Reader and Writer Classes for various scenario, for example BufferedReader and
BufferedWriter are example of decorator design pattern in Java. From design perspective its
also good idea to learn how existing things work inside JDK itself for example How HashMap
works in Java or How SubString method work in Java, that will give you some idea of things
you need to keep in mind while designing your Class or interface in Java. Now lets Move on
to Decorator pattern in Java.

Java Decorator Design Pattern

What is decorator design pattern in Java?

Decorator design pattern is used to enhance the functionality of a particular object at

run-time or dynamically.
At the same time other instance of same class will not be affected by this so
individual object gets the new behavior.
Basically we wrap the original object through decorator object.
Decorator design pattern is based on abstract classes and we derive concrete implementation
from those classes,
Its a structural design pattern and most widely used.
I prefer to answer What is decorator design pattern in point format just to stress on important
point like this pattern operator at individual object level. This question also asked in
many Core Java interviews in Investment banks

Problem which is solved by Decorator Pattern:

Now the question is why this pattern has came into existence what is the problem with
existing system, so the answer is if anyone wants to add some functionality to
individual object or change the state of particular object at run time it is not possible what the
possible is we can provide the specific behavior to all the object of that class at design time by
the help of inheritance or using subclass, but Decorator pattern makes possible that we
provide individual object of same class a specific behavior or state at run time. This doesnt
affect other object of same Class in Java.

When to use Decorator pattern in Java

When sub classing is become impractical and we need large number of different possibilities
to make independent object or we can say we have number of combination for an object.

Secondly when we want to add functionality to individual object not to all object at run-time
we use decorator design pattern.
Code Example of decorator design pattern:
To better understand concept of decorator design pattern let see a code example
using Decorator Pattern in Java. You can also look inside JDK and find what are classes and
packages which are using decorator pattern.
// Component on Decorator design pattern
public abstract class Currency {
String description = "Unknown currency";
public String getCurrencyDescription() {
return description;
}
public abstract double cost(double value);
}

// Concrete Component
public class Rupee extends Currency {
double value;
public Rupee() {
description = "indian rupees";
}
public double cost(double v){
value=v;
return value;
}
}
//Another Concrete Component
public class Dollar extends Currency{
double value;
public Dollar () {
description = "Dollar;
}
public double cost(double v){
value=v;
return value;
}
}
// Decorator
public abstract class Decorator extends Currency{

public abstract String getDescription();

}

// Concrete Decorator
public class USDDecorator extends Decorator{
Currency currency;

public USDDecorator(Currency currency){

this.currency = currency;
}

public String getDescription(){

return currency.getDescription()+" ,its US Dollar";
}

//Another Concrete Decorator

public class SGDDecorator extends Decorator{
Currency currency;
public SGDDecorator(Currency currency){
this.currency = currency;
}

public String getDescription(){

return currency.getDescription()+" ,its singapore Dollar";
}
}
Now its time to check currency.

public class CurrencyCheck {

public static void main(String[] args) {
// without adding decorators
Currency curr = new Dollar();
System.out.println(curr.getDescription() +" dollar. "+curr.cost(2.0));

//adding decorators

Currency curr2 = new USDDecorator(new Dollar());

System.out.println(curr2.getDescription() +" dollar. "+curr2.cost(4.0));
Currency curr3 = new SGDDecorator(new Dollar());
System.out.println(curr3.getDescription() +" dollar. "+curr3.cost(4.0));
}

Explanation of the code:

1.
2.
3.
4.

We can understand this in following term;

Component Interface: In our example Currency interface is component which used on its
own or we need decorator for that.
Concrete Component: it implements Component and we add new behavior to this object at
dynamically. Dollar and Rupee are the concrete implementation of currency.
Decorator: Decorator contains a HAS a Relationship in simple word we can say it has a
instance variable that holds reference for component they implement same component which
they are going to decorate. Here a Decorator is an abstract class which extends the currency.
Concrete Decorator: its an implementation of Decorator So USD Dollar and SGD Dollar are
the implementation of Decorator contains instance variable for component interface or the
thing which they are going to decorate.
Advantage of Decorator design Pattern in Java

1.
2.

In brief we see what the main advantages of using decorator design patterns are.
Decorator Pattern is flexible than inheritance because inheritance add responsibilities at
compile time and it will add at run-time.
Decorator pattern enhance or modify the object functionality
Disadvantage
Main disadvantage of using Decorator Pattern in Java is that the code maintenance can be a
problem as it provides a lot of similar kind of small objects (each decorator).

Observer design pattern in Java is a fundamental core Java pattern where Observe watch
for any change in state or property of Subject. For Example Company updates all its
shareholders for any decision they make here Company is Subject and Shareholders are
Observers, any change in policy of company and Company notifies all its Shareholders or
Observer. This was simple real world explanation of Observer pattern. In this article we will in
detail what is Observer Design pattern, what is benefit of Observer design Pattern, Example or
Observer pattern in Java and few other points. Just like Decorator design Pattern and Factory
Pattern in Java, Observer pattern is also used in JDK.

Observer design Pattern Java Code Example

What is Observer design Pattern?
Observer design pattern in Java is very important pattern and as name suggest its used to
observe things. Suppose you want to notify for change in a particular object than you observer
that object and changes are notified to you. Object which is being observed is refereed as
Subject and classes which observe subject are called Observer. This is beautiful pattern and
used heavily along with Model View Controller Design pattern where change in model is
propagated to view so that it can render it with modified information. Observer pattern is also
a very popular Java interview questions and mostly asked on Senior or mid senior level.

Problem which is solved by Observer Pattern:

If we have requirement that if particular object change its state and on depending upon
This changes some or group of objects automatically change their state we need to implement
observer pattern it will reduce coupling between objects.
In real world if try to find example see when we subscribe for New Phone connection whenever
customer is registered with that company all other departments are notified accordingly and
then depending upon the state the do their jobs like do the verification of their address then if
customer state is verified then dispatch the welcome kit etc.

How Observer Design Pattern is implemented in Java;

For implementation of this pattern java makes our task very easy, developer need not to do so
much for implementing this pattern .In java.util package we can find interfaces ,classes and
methods for implementing this pattern.
Public Interface Observer:
Any class who implements this interface must be notified when subject or observable object
change its status.
Update (Observable Ob, Object arg): This method is called when subject is changed.
Class Observable:
Its a subject to whom observer wants to observe.

Some Important Method:

addObserver(Observer o):add Observers in the set of observers for this subject or
observalbel object.
deleteObserver(Observer o): delete Observers in the set of observers .
hasChanged():check if object has changed.
clearChanged():this method will indicate that subject has no changes or all the observers
has been notified when changes is made.
notifyObservers(): notify all the observers if object has changed .

Code Example of Observer design pattern in Java:

Observer Design pattern is generic than how it is implemented in Java. You are free to
choose java.util.Observable or java.util.Observer or writing your own Subject and Observer
interface. I prefer having my own Subject and Observer interface and this is how I am going
to write my Code Example of Observer design Pattern in java. Mine Example is very Simple
you have a Loan on which interest rate is subject to change and when it changes, Loan notifies
to Newspaper or Internet media to display new loan interest rate. To implement this we have
a Subject interface which contains methods for adding, removing and notifying Observers and
an Observer interface which contains update(int interest) method which will be called by
Subject implementation when interest rate changes.
import java.util.ArrayList;
interface Observer {
public void update(float interest);
}
interface Subject {
public void registerObserver(Observer observer);
public void removeObserver(Observer observer);
public void notifyObservers();
}
class Loan implements Subject {
private ArrayList<Observer> observers = new ArrayList<Observer>();
private String type;
private float interest;
private String bank;
public Loan(String type, float interest, String bank) {
this.type = type;
this.interest = interest;
this.bank = bank;
}

public float getInterest() {

return interest;
}
public void setInterest(float interest) {
this.interest = interest;
notifyObservers();
}
public String getBank() {
return this.bank;
}
public String getType() {
return this.type;
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer ob : observers) {
System.out.println("Notifying Observers on change in Loan
interest rate");
ob.update(this.interest);
}
}
}
class Newspaper implements Observer {
@Override
public void update(float interest) {
System.out.println("Newspaper: Interest Rate updated, new Rate is:
"
+ interest);
}
}
class Internet implements Observer {
@Override
public void update(float interest) {
System.out.println("Internet: Interest Rate updated, new Rate is:
"
+ interest);
}

}
public class ObserverTest {
public static void main(String args[]) {
// this will maintain all loans information
Newspaper printMedia = new Newspaper();
Internet onlineMedia = new Internet();
Loan personalLoan = new Loan("Personal Loan", 12.5f,
"Standard Charterd");
personalLoan.registerObserver(printMedia);
personalLoan.registerObserver(onlineMedia);
personalLoan.setInterest(3.5f);
}
}

Advantage of Observer Design Pattern in Java:

Main advantage is loose coupling between objects called observer and observable. The
subject only know the list of observers it dont care about how they have their
implementation. All the observers are notified by subject in a single event call as Broadcast
communication

Disadvantage of Observer Design Pattern in Java:

The disadvantage is that the sometime if any problem comes, debugging becomes very
difficult because flow of control is implicitly between observers and observable we can
predict that now observer is going to fire and if there is chain between observers then
debugging become more complex.
Another issue is Memory management because subject will hold all the reference of all the
observers if we not unregister the object it can create the memory issue.

What is Factory method Design Pattern in Java with Example - Tutorial

Factory design pattern in Java one of the core design pattern which is used heavily not only in JDK but
also in various Open Source framework such as Spring, Struts and Apache along with decorator design
pattern in Java. Factory Design pattern is based on Encapsulation object oriented concept. Factory method
is used to create different object from factory often refereed as Item and it encapsulate the creation code. So
instead of having object creation code on client side we encapsulate inside Factory method in Java. One
of the best examples of factory pattern in Java is BorderFactory Class of Swing API. In this Design
pattern tutorial we will see What is Factory method design pattern in Java, What are main advantages of
factory pattern in Java , Code example of Factory design pattern and What problem Factory pattern solves
in Java or when to use Factory design pattern.

What is static factory method or factory design pattern

Factory design pattern is used to create objects or Class in Java and it provides loose coupling and high
cohesion. Factory pattern encapsulate object creation logic which makes it easy to change it later when you
change how object gets created or you can even introduce new object with just change in one class. In GOF
pattern list Factory pattern is listed as Creation design pattern. Factory should be an interface and clients
first either creates factory or get factory which later used to create objects.

Example of static factory method in JDK

Best Example of Factory method design pattern is valueOf() method which is there in String and wrapper
classes like Integer and Boolean and used for type conversion i.e. from converting String to Integer or String
to double in java..
Some more examples of factory method design pattern from JDK is :
valueOf() method which returns object created by factory equivalent to value of parameter passed.
getInstance() method which creates instance of Singleton class.
newInstance() method which is used to create and return new instance from factory method every time
called.
getType() and newType() equivalent of getInstance() and newInstance() factory method but
used when factory method resides in separate class.

Problem which is solved by Factory method Pattern in Java

Whenever we talk about object oriented language it will based upon some concept
like abstraction, polymorphism etc and on that encapsulation and delegation are important concept any
design will be called good if task are delegated to different object and some kind of encapsulation is there.
Some time our application or framework will not know that what kind of object it has to create at run-time it
knows only the interface or abstract class and as we know we can not create object of interface or abstract
class so main problem is frame work knows when it has to create but dont know what kind of object.

Whenever we create object using new() we violate principle of programming for interface rather than
implementation which eventually result in inflexible code and difficult to change in maintenance. By using
Factory design pattern in Java we get rid of this problem.
Another problem we can face is class needs to contain objects of other classes or class hierarchies within it;
this can be very easily achieved by just using the new keyword and the class constructor. The problem with
this approach is that it is a very hard coded approach to create objects as this creates dependency between
the two classes.
So factory pattern solve this problem very easily by model an interface for creating an object which at
creation time can let its subclasses decide which class to instantiate, Factory Pattern promotes loose
coupling by eliminating the need to bind application-specific classes into the code. The factory methods are
typically implemented as virtual methods, so this pattern is also referred to as the Virtual Constructor.
These methods create the objects of the products or target classes.

When to use Factory design pattern in Java

Static Factory methods are common in frameworks where library code needs to create objects of
types which may be sub classed by applications using the framework.

Some or all concrete products can be created in multiple ways, or we want to leave open the option
that in the future there may be new ways to create the concrete product.

Factory method is used when Products don't need to know how they are created.

We can use factory pattern where we have to create an object of any one of sub-classes
depending on the data provided

Code Example of Factory Design Pattern in Java:

Lets see an example of how factory pattern is implemented in Code.We have requirement to create multiple
currency e.g. INR, SGD, USD and code should be extensible to accommodate new Currency as well. Here
we have made Currency as interface and all currency would be concrete implementation of Currency
interface. Factory Class will create Currency based upon country and return concrete implementation which
will be stored in interface type. This makes code dynamic and extensible.
Here is complete code example of Factory pattern in Java:
interface Currency {
String getSymbol();
}
// Concrete Rupee Class code
class Rupee implements Currency {
@Override
public String getSymbol() {
return "Rs";
}
}
// Concrete SGD class Code
class SGDDollar implements Currency {
@Override
public String getSymbol() {
return "SGD";
}
}

// Concrete US Dollar code

class USDollar implements Currency {
@Override
public String getSymbol() {
return "USD";
}
}
// Factroy Class code
class CurrencyFactory {
public static Currency createCurrency (String country) {
if (country. equalsIgnoreCase ("India")){
return new Rupee();
}else if(country. equalsIgnoreCase ("Singapore")){
return new SGDDollar();
}else if(country. equalsIgnoreCase ("US")){
return new USDollar();
}
throw new IllegalArgumentException("No such currency");
}
}
// Factory client code
public class Factory {
public static void main(String args[]) {
String country = args[0];
Currency rupee = CurrencyFactory.createCurrency(country);
System.out.println(rupee.getSymbol());
}
}

Advantage of Factory method Pattern in Java:

Factory pattern in Java is heavily used everywhere including JDK, open source library and other
frameworks.In following are main advantages of using Factory pattern in Java:
1) Factory method design pattern decouples the calling class from the target class, which result in less
coupled and highly cohesive code?
E.g.: JDBC is a good example for this pattern; application code doesn't need to know what database it will
be used with, so it doesn't know what database-specific driver classes it should use. Instead, it uses factory
methods to get Connections, Statements, and other objects to work with. Which gives you flexibility to
change your back-end database without changing your DAO layer in case you are using ANSI SQL features
and not coded on DBMS specific feature?
2) Factory pattern in Java enables the subclasses to provide extended version of an object, because
creating an object inside factory is more flexible than creating an object directly in the client. Since client is
working on interface level any time you can enhance the implementation and return from Factory.
3) Another benefit of using Factory design pattern in Java is that it encourages consistency in Code since
every time object is created using Factory rather than using different constructor at different client side.
4) Code written using Factory design pattern in Java is also easy to debug and troubleshoot because you
have a centralized method for object creation and every client is getting object from same place.

Some more advantages of factory method design pattern is:

1. Static factory method used in factory design pattern enforces use of Interface than implementation
which itself a good practice. for example:
Map synchronizedMap = Collections.synchronizedMap(new HashMap());
2. Since static factory method have return type as Interface, it allows you to replace implementation with
better performance version in newer release.
3. Another advantage of static factory method pattern is that they can cache frequently used object and
eliminate duplicate object creation. Boolean.valueOf() method is good example which caches true and
false boolean value.
4. Factory method pattern is also recommended by Joshua Bloch in Effective Java.
5 Factory method pattern offers alternative way of creating object.
6. Factory pattern can also be used to hide information related to creation of object.