Abstract Factory Design Pattern in Kotlin

1. Definition

The Abstract Factory Design Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

2. Problem Statement

When systems need to be configured with multiple families of products and you want to ensure that a system uses only products from a single family, direct object instantiation can become problematic. This is because it may introduce dependencies between concrete classes, violating the dependency inversion principle.

3. Solution

Use the Abstract Factory pattern to declare interfaces for creating a set of products (each product representing a part of a product family). Then, allow the client to use these interfaces to produce a family of related products by specifying the type of factory (which determines the family of created products).

4. Real-World Use Cases

1. GUI toolkits that need to provide a consistent look and feel across platforms.

2. Creating product sets with different configurations or variations.

5. Implementation Steps

1. Define product interfaces for each type of product to be produced.

2. Implement these interfaces in concrete product classes.

3. Create an abstract factory interface to declare creation methods for each type of product.

4. Concrete factories implement this interface to produce products that conform to one family.

6. Implementation in Kotlin

// Step 1: Product Interfaces
interface Button {
    fun paint(): String

interface Window {
    fun render(): String

// Step 2: Concrete Products for each family
class MacOSButton : Button {
    override fun paint() = "MacOS Button"

class MacOSWindow : Window {
    override fun render() = "MacOS Window"

class WindowsButton : Button {
    override fun paint() = "Windows Button"

class WindowsWindow : Window {
    override fun render() = "Windows Window"

// Step 3: Abstract Factory Interface
interface GUIFactory {
    fun createButton(): Button
    fun createWindow(): Window

// Step 4: Concrete Factories
class MacOSFactory : GUIFactory {
    override fun createButton() = MacOSButton()
    override fun createWindow() = MacOSWindow()

class WindowsFactory : GUIFactory {
    override fun createButton() = WindowsButton()
    override fun createWindow() = WindowsWindow()

fun clientCode(factory: GUIFactory) {
    val button = factory.createButton()
    val window = factory.createWindow()

fun main() {
    val factory1 = MacOSFactory()
    clientCode(factory1)  // Using MacOS GUI elements

    val factory2 = WindowsFactory()
    clientCode(factory2)  // Using Windows GUI elements


MacOS Button
MacOS Window
Windows Button
Windows Window


1. We define Button and Window as product interfaces.

2. Each product interface is then implemented for different "families" of products (in this case, MacOS and Windows).

3. An abstract factory interface (GUIFactory) is created to declare methods for producing each product.

4. Concrete factories (MacOSFactory and WindowsFactory) are then created to produce products from a particular family.

5. The clientCode function is an example of how a client might use the Abstract Factory to create and use products.

6. In the main function, we demonstrate the creation of GUI elements for both MacOS and Windows using their respective factories.

7. When to use?

The Abstract Factory pattern is useful when:

1. A system needs to be independent of how its objects are created, composed, and represented.

2. A family of product objects is designed to be used together, and this constraint needs to be enforced.

3. You want to expose only product creation interfaces without revealing the actual product implementation.

4. The system needs to be configured with one of multiple families of products.

By employing the Abstract Factory, we can introduce new families of products easily without altering existing code, adhering to the open/closed principle.