What is the difference between Builder Design pattern and Factory Design pattern? [closed]

by

With design patterns, there usually is no “more advantageous” solution that works for all cases. It depends on what you need to implement.

From Wikipedia:

  • Builder focuses on constructing a
    complex object step by step. Abstract
    Factory emphasizes a family of product
    objects (either simple or complex).
    Builder returns the product as a final
    step, but as far as the Abstract
    Factory is concerned, the product gets
    returned immediately.
  • Builder often builds a Composite.
  • Often, designs start out using Factory Method (less complicated, more
    customizable, subclasses proliferate)
    and evolve toward Abstract Factory,
    Prototype, or Builder (more flexible,
    more complex) as the designer
    discovers where more flexibility is
    needed.
  • Sometimes creational patterns are complementary: Builder can use one
    of the other patterns to implement
    which components get built. Abstract
    Factory, Builder, and Prototype can
    use Singleton in their
    implementations.

Wikipedia entry for factory design pattern:
http://en.wikipedia.org/wiki/Factory_method_pattern

Wikipedia entry for builder design pattern:
http://en.wikipedia.org/wiki/Builder_pattern

More Related Contents:

  1. Factory Pattern. When to use factory methods?
  2. What are the differences between Abstract Factory and Factory design patterns?
  3. Design Patterns: Abstract Factory vs Factory Method
  4. What is the basic difference between the Factory and Abstract Factory Design Patterns? [closed]
  5. Factory, Abstract Factory and Factory Method
  6. What is dependency injection?
  7. Why is Singleton considered an anti-pattern? [duplicate]
  8. How to implement the factory method pattern in C++ correctly
  9. Dependency Injection vs Factory Pattern
  10. How do the Proxy, Decorator, Adapter, and Bridge Patterns differ?
  11. What is a wrapper class?
  12. How will I know when to create an interface?
  13. What’s the difference between the Dependency Injection and Service Locator patterns?
  14. Which Typesafe Enum in C++ Are You Using?
  15. How to avoid ‘instanceof’ when implementing factory design pattern?
  16. Are utility classes evil? [closed]
  17. Relational Database Design Patterns? [closed]
  18. Singleton pattern [closed]
  19. What’s the difference between design patterns and architectural patterns? [closed]
  20. Are there any viable alternatives to the GOF Singleton Pattern?
  21. When should you use the singleton pattern instead of a static class? [closed]
  22. Is global constants an anti-pattern?
  23. What is the difference between Factory and Strategy patterns?
  24. REST API Login Pattern
  25. Using a strategy pattern and a command pattern
  26. How do you know when to use design patterns? [closed]
  27. Static factory methods vs Instance (normal) constructors?
  28. What would a Log4Net Wrapper class look like?
  29. When do we need decorator pattern?
  30. Difference betwen Visitor pattern & Double Dispatch

Leave a Comment