Talk:Builder pattern

Builders and immutable objects

A major benefit of builders is that they can be used to create immutable objects without complex constructors. In Java, the builder pattern also simulates named constructor parameters:

public final class Pizza {
    private final String dough;
    private final String sauce;
    private final String topping;

    private Pizza(Builder builder) {
        dough = builder.dough;
        sauce = builder.sauce;
        topping = builder.topping;
    }

    public static class Builder {
        private String dough;
        private String sauce;
        private String topping;

        public Builder dough(String dough) {
            this.dough = dough; 
            return this;
        }
        public Builder sauce(String sauce) {
            this.sauce = sauce; 
            return this;
        }
        public Builder topping(String topping) {
            this.topping = topping;
            return this;
        }

        public Pizza create() {
            return new Pizza(dough, sauce, topping);
        }
    }
}
 
/** A customer ordering a pizza. */
class BuilderExample {
    public static void main(String[] args) {
        Pizza hawaiian = new Builder()
             .dough("cross")
             .sauce("mild")
             .topping("ham+pineapple")
             .create();
    }
}

Abstract Builder class

In the diagram, the Builder should be italicized to indicate that it is an Abstract class. If it is an interface rather than abstract class (alá Java), then it would be better served with an <<interface>> stereotype. —Preceding unsigned comment added by 71.57.242.240 (talk) 22:06, 12 February 2008 (UTC)

Correspondance between the sequence diagram and the Java program

The Sequence diagram dosen't seems to correspond to the example in Java any toughts ? --Khalid hassani 11:15, 11 August 2006 (UTC)

Adding a section about the difference between Factory Method pattern and Builder pattern

Many people especially beginners are confused about the difference between those two patterns, as they seem very similar, we need to add a section about the difference between the two patterns, the google groups discussion in the External links section seems a good starting point to me.--Khalid hassani 11:19, 11 August 2006 (UTC)

Class data members should be private, chefs create pizza

The abstract class PizzaBuilder should not have a protected Pizza data member this should be private. Having protected data creates fragile class hierarchies and generally should be avoided. Also a minor point, but generally chefs do the cooking not waiters!

Yeah, I think the Java example should be refactored. Nobnak (talk) 01:58, 3 September 2010 (UTC)

Ambiguity? Or am I just confused...

The explanation for the Director class is: "The Director class is responsible for managing the correct sequence of object creation. It receives a Concrete Builder as a parameter and executes the necessary operations on it."

Under the "Difference Between Builder pattern and Abstract factory pattern" heading, this is mentioned: "...the client just requests a configuration and the builder directs the logic of building it"

This seems to say that the Builder manages "the correct sequence of object creation". Is the client the "Director" or is the builder the "Director"? —The preceding unsigned comment was added by 61.14.96.7 (talk) 07:51, 30 April 2007 (UTC).

Missing the Mark

Previous commentor: You're not confused. The author of this article is deeply confused about the Builder pattern. The sample cited in the first comment above better represents what a Builder is. —Preceding unsigned comment added by Jdmarshall (talk • contribs) 23:19, 17 December 2007 (UTC)

Yeah, this article is totally duff. Where do we get these guys? -- TomAnderson —Preceding unsigned comment added by 128.40.81.110 (talk) 18:24, 12 May 2008 (UTC)

Most of this page is copied

Most of the text for this page is copied directly from http://sourcemaking.com/design_patterns/builder in violation of its license terms. That work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License. This page does not attribute the work to its original author.

Vaughanje (talk) 19:51, 12 May 2008 (UTC)

Sorry, I don't see the similarity. The only part that is similar is the introductory sentence, which both authors seem to have lifted verbatim from the GoF book, and the secondary concepts, which also, you guessed it, come from the GoF book. Jdmarshall (talk) 11:58, 18 May 2008 (UTC)

I agree that there is little similarity with http://sourcemaking.com/design_patterns/builder, but I am concerned that the Pizza example is too similar to the example in Head First Design Patterns. AllenDowney (talk) 13:57, 21 April 2011 (UTC)

Class diagram glitch

The Builder in the class diagram is not an <<interface>>, but it should be (also for the sake of calling the other class ConcreteBuilder). --78.43.87.113 (talk) 14:49, 7 August 2008 (UTC)

Example more like Abstract-factory

The example given leans more towards abstract factory. As mentioned, Builder is best used for building up Composites. So, Menu Items in menu system, or Genealogy tree of parents and children. Builders can use factories, and often do. This is why the example is confusing. It is attempting to use factories and be a builder at the same time. An improvement to the example would be to have a PizzaFactory, a SoftDrinkFactory and SideOrderFactory. Then, create an OrderBuilder that would build up an order using these factories. I'm not saying that this is the best example, but much clearer than what is there now. A simpler example, like building up a MenuSystem for an application, would be much clearer. —Preceding unsigned comment added by Hosick (talk • contribs) 07:44, 17 May 2009 (UTC)

Abstract functions?

Gang of Four says not to use abstract functions, but instead use empty functions. Normally on a builder pattern you may not want to implement everything, if you set abstract functions then you'll be forced to implement them, even if it was empty. - 114.76.239.105 (talk) 15:11, 26 December 2010 (UTC)

Is this the best way of doing this?

public class BuilderExample {
	public static void main(String[] args) {
		Cook cook = new Cook();
		PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
		PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
 
		cook.setPizzaBuilder(hawaiianPizzaBuilder);
		cook.constructPizza();

		Pizza hawaiian = cook.getPizza();
 
		cook.setPizzaBuilder(spicyPizzaBuilder);
		cook.constructPizza();
 
		Pizza spicy = cook.getPizza();
	}
}

Wouldn't it be better to do something like the following:

public class BuilderExample {
	public static void main(String[] args) {
		Cook cook = new Cook();
		PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
		PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
 
		cook.constructPizza(hawaiianPizzaBuilder);
		Pizza hawaiian = hawaiianPizzaBuilder.getPizza();
 
		cook.constructPizza(spicyPizzaBuilder);
		Pizza spicy = spicyPizzaBuilder.getPizza();
	}
}

The Gang of Four have an interaction diagram that shows that you get the resulting product from the builder. I can't see any reason why you would need a setPizzaBuilder setter - you would just pass the pizzaBuilder in as a parameter. This leads to cleaner code, IMO. - FluffySquid (talk) 14:11, 17 January 2011 (UTC)

Two example implementations

I'm not sure we need two example implementations. C++ and Java are not radically different in syntax, and there's nothing about the pattern that can't be covered in one. — anndelion ❋ 21:40, 18 April 2011 (UTC)

C# implementation

In keeping with C# style, shouldn't properties be used instead of java-like setters?

 
public string Dough { 
  get {return _dough;}
  set {
    (do class specific checking...) 
    _dough = value;
  }
}
...

Critics

I'm missing the critics section, because the builder pattern is just deeply bad Java, creating a unecessary complex code and nothing else. Probably those people programming builders didn't understand what a constructor is and what a setter and a getter is. Too bad. It should be forbidden. Furthermore, builder are not real object oriented code, so they also need callback patterns, like in the old days with Fortran and C. But callbacks should nowadays be used only for assymetric processes, and not for models at all. That's probably why we need (only) one new programming language in the future, prohibitting all those bad implementation patterns. Or, at least a Java compiler who prohibits it. 178.197.234.31 (talk) 13:36, 6 June 2013 (UTC)

If somebody comes and says "how am I supposed to do fast parsing without a builder?", you are right in using a builder for loops, like a StringBuilder. But this is a very special case and is only used for parsing Strings. However, for normal objects you should use Externalizable to parse them (newer use Serialisation because it's only 30% Externalizable's speed). So please don't misunderstand me: Builder are okey in a very limited case of String parsing...but then we create the StringBuilder, use it instantly in a loop and afterwards we forget about it. But to use the builder pattern for more than String parsing is just dumb. 178.197.236.254 (talk) 14:36, 6 June 2013 (UTC)

Using setters is not a replacement, because setters can cause the object to have an unstable and incomplete form. Builder pattern guarantees that the only object that is modified is the intermediatate object used while creating the final product. When the intermediate object is used up it is discarded. Builder pattern also allows flexible object construction. Suppose you have an object that might need many parameters. — Preceding unsigned comment added by 130.243.188.76 (talk) 22:50, 13 December 2013 (UTC)

Wrong example

The pseudocode example does not illustrate the full pattern as described in the GoF book. While we can identify a concrete Builder (CarBuilder) and the product (Car), the Director is somewhat implicit and there is no base Builder class to inherit from.

Javierieh (talk) 02:51, 11 November 2014 (UTC)