Explore Topics
🎯
Intent
One factory interface, many compatible product families — pick the family at runtime.
🏭 Family Matrix Switcher — one factory, one complete family
// CLIENT CODE — abstract types only, does NOT change when you swap the factory
FurnitureFactory factory = new ModernFactory();
Chair chair = factory.createChair();
Sofa sofa = factory.createSofa();
CoffeeTable table = factory.createCoffeeTable();
Family Matrix · variants × product types
🪑Chair
🛋️Sofa
☕CoffeeTable
ModernChairminimal steel + beige fabric
ModernSofa3-seat low profile, oak legs
ModernCoffeeTableround glass top, chrome base
VictorianChaircarved mahogany, velvet uphol.
VictorianSofatufted, button-back, claw feet
VictorianCoffeeTableornate walnut, marble inlay
ArtDecoChairgeometric brass, lacquered seat
ArtDecoSofabold curves, gold accents, velvet
ArtDecoCoffeeTablestepped marble, gilded edges
Pick a row → the entire row lights up. ALL three products come from the SAME family.
Mixing rows is impossible — that's the family-cohesion guarantee.
Mixing rows is impossible — that's the family-cohesion guarantee.
🏠 Showroom Preview · Modern family
minimal forms, steel, glass, oak — Bauhaus-inflected
🪑ModernChairminimal steel + beige fabric
🛋️ModernSofa3-seat low profile, oak legs
☕ModernCoffeeTableround glass top, chrome base
✓ All three products share the modern family
Hide 2 product columns → you have Factory Method. Add more product columns → richer family.
🎯
Intent
One factory interface, many compatible product families — pick the family at runtime.
Abstract Factory is a creational pattern that provides an interface for creating FAMILIES of related products without specifying their concrete classes. Where Factory Method has ONE polymorphic factory method per Creator subclass (one product type), Abstract Factory bundles MULTIPLE factory methods on a single AbstractFactory interface — one per product type in the family. The client picks a ConcreteFactory once at startup; from then on every product the client receives is guaranteed to come from the same family. This is why Abstract Factory is often called the "factory of factories": each concrete factory groups several individual factory methods into a single coordinated bundle, and switching factories swaps the whole bundle atomically.
Key Ideas
- A FAMILY of related products is created together, not one product at a time.
- The client depends only on the AbstractFactory interface and abstract Product interfaces.
- Switching ConcreteFactory swaps the ENTIRE family — never a mix of variants.
- Each create*() method on the AbstractFactory is conceptually a Factory Method — Abstract Factory composes several of them.
- "Factory of factories" — one ConcreteFactory packages several Factory Method overrides into one coordinated bundle.
Strengths
- ✦Guarantees compatible products are used together (no family mismatches)
- ✦Isolates concrete classes — client never names a ConcreteProduct
- ✦Swapping families = swapping ONE factory reference at startup
- ✦Each ConcreteFactory has a single responsibility: produce ONE complete family
Weaknesses
- △Requires inheritance AND composition — heavier than Factory Method
- △Class explosion: N variants × M product types + 2N abstract types
- △Adding a NEW product type to the family requires editing the AbstractFactory interface AND every ConcreteFactory
- △Overkill when the product family is fixed or small
Used in:The JDK uses Abstract Factory in `javax.xml.parsers.DocumentBuilderFactory`: pick a concrete factory once (`newInstance()` reads system properties to choose Xerces, Crimson, or another XML implementation), and from then on every `DocumentBuilder` and `Document` produced comes from that one implementation family. Switching the system property at startup re-themes the entire XML parsing stack without changing application code.
Code Snippets
Quiz
Intent Quiz
QUIZ 1/6Which statement best captures the GoF Intent of the Abstract Factory pattern?
Diagrams
Practice
Drag each class from the FurnitureShopApp into the GoF Abstract Factory participant role it plays. Each role accepts exactly two classes.
EXERCISE 1/4Chair (interface with describe method)
Sofa (interface with describe method)
ModernChair (implements Chair.describe)
VictorianSofa (implements Sofa.describe)
FurnitureFactory (interface with createChair, createSofa, createCoffeeTable)
MotorhomeFactory (interface with createFrame, createStyle, createEngine, createKitchen)
ModernFactory (implements FurnitureFactory)
TypeBFactory (implements MotorhomeFactory)
Showroom (uses an injected FurnitureFactory)
Manufacturer (uses an injected MotorhomeFactory)
Abstract Product
Concrete Product
Abstract Factory
Concrete Factory
Client
Spot the bug — why does this client defeat the Abstract Factory pattern?
EXERCISE 2/4Click on the line you think contains the bug, then press Confirm.
Order the 6 GoF implementation steps for refactoring scattered `new` to Abstract Factory
EXERCISE 3/4Drag the lines into the correct order.
1. Draw the product MATRIX (M product types × N variants) to see the shape and class count.
2. Declare M abstract product interfaces, one per product type in the family.
3. Make every existing concrete product class implement its abstract product interface.
4. Declare the AbstractFactory interface with N create*() methods, one per product type.
5. Implement one ConcreteFactory per variant; every create*() returns a product of that variant.
6. Replace direct `new ConcreteProduct()` calls in client code with `factory.createX()` calls; inject the factory at startup.
Abstract Factory myths and gotchas — true or false?
EXERCISE 4/4Abstract Factory is the same as Factory Method.
Abstract Factory internally uses Factory Method to implement each create*() method.
Adding a new VARIANT to an Abstract Factory requires editing existing code.
Adding a new PRODUCT TYPE to an Abstract Factory requires editing existing code.
The client of an Abstract Factory must know all the concrete product class names to call factory.createX().
Abstract Factory and Singleton are often combined in practice.
Abstract Factory eliminates the need for the `new` keyword entirely in client code.