Tutorial

Builder Design Pattern in Java

Published on August 3, 2022
Default avatar

By Pankaj

Builder Design Pattern in Java

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Today we will look into Builder pattern in java. Builder design pattern is a creational design pattern like Factory Pattern and Abstract Factory Pattern.

Builder Design Pattern

builder pattern in java, builder design pattern, builder pattern Builder pattern was introduced to solve some of the problems with Factory and Abstract Factory design patterns when the Object contains a lot of attributes. There are three major issues with Factory and Abstract Factory design patterns when the Object contains a lot of attributes.

  1. Too Many arguments to pass from client program to the Factory class that can be error prone because most of the time, the type of arguments are same and from client side its hard to maintain the order of the argument.
  2. Some of the parameters might be optional but in Factory pattern, we are forced to send all the parameters and optional parameters need to send as NULL.
  3. If the object is heavy and its creation is complex, then all that complexity will be part of Factory classes that is confusing.

We can solve the issues with large number of parameters by providing a constructor with required parameters and then different setter methods to set the optional parameters. The problem with this approach is that the Object state will be inconsistent until unless all the attributes are set explicitly. Builder pattern solves the issue with large number of optional parameters and inconsistent state by providing a way to build the object step-by-step and provide a method that will actually return the final Object.

Builder Design Pattern in Java

Let’s see how we can implement builder design pattern in java.

  1. First of all you need to create a static nested class and then copy all the arguments from the outer class to the Builder class. We should follow the naming convention and if the class name is Computer then builder class should be named as ComputerBuilder.
  2. Java Builder class should have a public constructor with all the required attributes as parameters.
  3. Java Builder class should have methods to set the optional parameters and it should return the same Builder object after setting the optional attribute.
  4. The final step is to provide a build() method in the builder class that will return the Object needed by client program. For this we need to have a private constructor in the Class with Builder class as argument.

Here is the sample builder pattern example code where we have a Computer class and ComputerBuilder class to build it.

package com.journaldev.design.builder;

public class Computer {
	
	//required parameters
	private String HDD;
	private String RAM;
	
	//optional parameters
	private boolean isGraphicsCardEnabled;
	private boolean isBluetoothEnabled;
	

	public String getHDD() {
		return HDD;
	}

	public String getRAM() {
		return RAM;
	}

	public boolean isGraphicsCardEnabled() {
		return isGraphicsCardEnabled;
	}

	public boolean isBluetoothEnabled() {
		return isBluetoothEnabled;
	}
	
	private Computer(ComputerBuilder builder) {
		this.HDD=builder.HDD;
		this.RAM=builder.RAM;
		this.isGraphicsCardEnabled=builder.isGraphicsCardEnabled;
		this.isBluetoothEnabled=builder.isBluetoothEnabled;
	}
	
	//Builder Class
	public static class ComputerBuilder{

		// required parameters
		private String HDD;
		private String RAM;

		// optional parameters
		private boolean isGraphicsCardEnabled;
		private boolean isBluetoothEnabled;
		
		public ComputerBuilder(String hdd, String ram){
			this.HDD=hdd;
			this.RAM=ram;
		}

		public ComputerBuilder setGraphicsCardEnabled(boolean isGraphicsCardEnabled) {
			this.isGraphicsCardEnabled = isGraphicsCardEnabled;
			return this;
		}

		public ComputerBuilder setBluetoothEnabled(boolean isBluetoothEnabled) {
			this.isBluetoothEnabled = isBluetoothEnabled;
			return this;
		}
		
		public Computer build(){
			return new Computer(this);
		}

	}

}

Notice that Computer class has only getter methods and no public constructor. So the only way to get a Computer object is through the ComputerBuilder class. Here is a builder pattern example test program showing how to use Builder class to get the object.

package com.journaldev.design.test;

import com.journaldev.design.builder.Computer;

public class TestBuilderPattern {

	public static void main(String[] args) {
		//Using builder to get the object in a single line of code and 
                //without any inconsistent state or arguments management issues		
		Computer comp = new Computer.ComputerBuilder(
				"500 GB", "2 GB").setBluetoothEnabled(true)
				.setGraphicsCardEnabled(true).build();
	}

}

Builder Design Pattern Video Tutorial

Recently I uploaded a YouTube video for Builder Design Pattern. I have also explained why I think the builder pattern defined on WikiPedia using Director classes is not a very good Object Oriented approach, and how we can achieve the same level of abstraction using different approach and with one class. Note that this is my point of view, I feel design patterns are to guide us, but ultimately we have to decide if it’s really beneficial to implement it in our project or not. I am a firm believer of KISS principle. https://www.youtube.com/watch?v=D5NK5qMM14g If you like the video, please do share it, like it and subscribe to my channel. If you think I am mistaken or you have any comments or feedback so that I can improve my videos in future, please let me know through comments here or on YouTube video page.

Builder Design Pattern Example in JDK

Some of the builder pattern example in Java classes are;

  • java.lang.StringBuilder#append() (unsynchronized)
  • java.lang.StringBuffer#append() (synchronized)

That’s all for builder design pattern in java.

You can download the example code from my GitHub Repository.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about us


About the authors
Default avatar
Pankaj

author

Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?
 
JournalDev
DigitalOcean Employee
DigitalOcean Employee badge
December 1, 2021

I have just started to learning Design Patterns. I watch a video course on Udemy on Design Patterns but I understand more from your tutorials than those videos. Like the way you are teaching. Keep it up.

- Nitin Sangale

    JournalDev
    DigitalOcean Employee
    DigitalOcean Employee badge
    September 23, 2020

    Why are we using inner class here? We can create a constructor of Computer as like ComputerBuilder and set the optional field by setter as you are doing with ComputerBulder.

    - Ravi

      JournalDev
      DigitalOcean Employee
      DigitalOcean Employee badge
      January 29, 2020

      Hi Pankaj, Can you explain " The problem with this approach is that the Object state will be inconsistent until unless all the attributes are set explicitly." this line in more detail.

      - Hey

        JournalDev
        DigitalOcean Employee
        DigitalOcean Employee badge
        November 27, 2019

        Hello, Thank you for your presentation, I have something wrong with your example: You said " I resolved the issue about a lot of arguments but I don’t see your example can keep the benefit of Factory and AbsFactory ? Thanks

        - Ncsthanh

          JournalDev
          DigitalOcean Employee
          DigitalOcean Employee badge
          July 10, 2019

          While I’m reading the book writen by GOF, the book mentioned that Builder Pattern Constructure including three parts: Director, Builder, ConcreteBuilder. However, I haven’t saw the Builder in your codes, what’s more, the book also mentioned that a Builder may have several ConcreteBuilders, which I couldn’t understand.

          - xun yan

            JournalDev
            DigitalOcean Employee
            DigitalOcean Employee badge
            January 26, 2019

            if computer is a component interface say apple’s Mac and you want to create its instance is it possible for you to assemble hard disk monitor etc… so the component interfaces or classes which object creation is very complex we use factory Method design pattern but its have limitation and suitable for less data if you want to populate with big data then builder pattern is best one and for that you have to give all complex data to builder class…

            - ISHANYA

              JournalDev
              DigitalOcean Employee
              DigitalOcean Employee badge
              July 20, 2018

              Hey man thanks for this nice video/Article I have a question. What if you are working with POJO that you need to persist with Jpa/Hibernate. Do we need the setters for that?

              - Mehdi Ahmed

                JournalDev
                DigitalOcean Employee
                DigitalOcean Employee badge
                July 12, 2018

                Since we have to invoke the constructors and setter methods explicitly anyway, cant we do it directly on the computer class via a public constructor? Why did we even need the inner class ??

                - Bismeet

                  JournalDev
                  DigitalOcean Employee
                  DigitalOcean Employee badge
                  July 1, 2018

                  This is a different version of Builder pattern which I have come to know but definitely its a way of implementing things. Thanks for sharing this with the code.

                  - Ujjawal Besra

                    JournalDev
                    DigitalOcean Employee
                    DigitalOcean Employee badge
                    May 30, 2018

                    If you are copying same data from compute calss to computer builder class and pass those parameters from client to builder . . Why are we doing this , why cant we directly instantiate object of computer from client . What is the use of builder pattern . Because you are any way having constructer in builder class for which client needs to send parameters , in the same way we can declare constructer in main class itself and parameters from client. You example is not clear why to use builder pattern.

                    - satya

                      Try DigitalOcean for free

                      Click below to sign up and get $200 of credit to try our products over 60 days!

                      Sign up

                      Join the Tech Talk
                      Success! Thank you! Please check your email for further details.

                      Please complete your information!

                      Get our biweekly newsletter

                      Sign up for Infrastructure as a Newsletter.

                      Hollie's Hub for Good

                      Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

                      Become a contributor

                      Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

                      Welcome to the developer cloud

                      DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

                      Learn more
                      DigitalOcean Cloud Control Panel