Skip to main content

Abstract Factory

Overview​

Provide an interface for creating families of related objects without specifying their concrete classes.

When to use​

  • You need consistent object families (for example, UI theme widgets).
  • You want to switch product families at runtime.

Java example​

interface Button {
    String render();
}

interface Input {
    String render();
}

class LightButton implements Button {
    public String render() {
        return "light-button";
    }
}

class LightInput implements Input {
    public String render() {
        return "light-input";
    }
}

class DarkButton implements Button {
    public String render() {
        return "dark-button";
    }
}

class DarkInput implements Input {
    public String render() {
        return "dark-input";
    }
}

interface UiFactory {
    Button createButton();
    Input createInput();
}

class LightUiFactory implements UiFactory {
    public Button createButton() {
        return new LightButton();
    }

    public Input createInput() {
        return new LightInput();
    }
}

class DarkUiFactory implements UiFactory {
    public Button createButton() {
        return new DarkButton();
    }

    public Input createInput() {
        return new DarkInput();
    }
}

TypeScript example​

interface Button {
  render(): string;
}

interface Input {
  render(): string;
}

class LightButton implements Button {
  render(): string {
    return 'light-button';
  }
}

class LightInput implements Input {
  render(): string {
    return 'light-input';
  }
}

class DarkButton implements Button {
  render(): string {
    return 'dark-button';
  }
}

class DarkInput implements Input {
  render(): string {
    return 'dark-input';
  }
}

interface UiFactory {
  createButton(): Button;
  createInput(): Input;
}

class LightUiFactory implements UiFactory {
  createButton(): Button {
    return new LightButton();
  }

  createInput(): Input {
    return new LightInput();
  }
}

class DarkUiFactory implements UiFactory {
  createButton(): Button {
    return new DarkButton();
  }

  createInput(): Input {
    return new DarkInput();
  }
}

Pros and cons​

Pros:

  • Ensures consistent product families.
  • Swappable factories improve flexibility.

Cons:

  • More interfaces and classes.
  • Harder to add new product types.

Common pitfalls​

  • Mixing products from different families.
  • Introducing too many factory layers.