Skip to content

Creational Design Patterns

Creational Design Patterns provide various object creation mechanisms, which increase flexibility and reuse of existing code.

2. Factory Method

The Factory Method Design Pattern is a creational design pattern used in software engineering to provide an interface for creating objects in a superclass, while allowing subclasses to alter the type of objects that will be created.

DesignTool

Bases: ABC

Abstract base class for design tools.

Source code in src/creational/factory.py 
11
12
13
14
15
16
17
class DesignTool(ABC):
    """Abstract base class for design tools."""

    @abstractmethod
    def createDesign(self) -> None:
        """Creates a design using the respective design tool."""
        pass

createDesign() abstractmethod

Creates a design using the respective design tool.

Source code in src/creational/factory.py 
14
15
16
17
@abstractmethod
def createDesign(self) -> None:
    """Creates a design using the respective design tool."""
    pass

Figma

Bases: DesignTool

Concrete implementation of the DesignTool interface for Figma.

Source code in src/creational/factory.py 
20
21
22
23
24
25
class Figma(DesignTool):
    """Concrete implementation of the DesignTool interface for Figma."""

    def createDesign(self) -> None:
        """Creates a design using Figma."""
        return "creating a design using Figma!"

createDesign()

Creates a design using Figma.

Source code in src/creational/factory.py 
23
24
25
def createDesign(self) -> None:
    """Creates a design using Figma."""
    return "creating a design using Figma!"

AdobeXD

Bases: DesignTool

Concrete implementation of the DesignTool interface for AdobeXD.

Source code in src/creational/factory.py 
28
29
30
31
32
33
class AdobeXD(DesignTool):
    """Concrete implementation of the DesignTool interface for AdobeXD."""

    def createDesign(self) -> None:
        """Creates a design using AdobeXD."""
        return "creating a design using AdobeXD!"

createDesign()

Creates a design using AdobeXD.

Source code in src/creational/factory.py 
31
32
33
def createDesign(self) -> None:
    """Creates a design using AdobeXD."""
    return "creating a design using AdobeXD!"

Zeplin

Bases: DesignTool

Concrete implementation of the DesignTool interface for Zeplin.

Source code in src/creational/factory.py 
36
37
38
39
40
41
class Zeplin(DesignTool):
    """Concrete implementation of the DesignTool interface for Zeplin."""

    def createDesign(self) -> None:
        """Creates a design using Zeplin."""
        return "creating a design using Zeplin!"

createDesign()

Creates a design using Zeplin.

Source code in src/creational/factory.py 
39
40
41
def createDesign(self) -> None:
    """Creates a design using Zeplin."""
    return "creating a design using Zeplin!"

DesignToolProvider

Bases: ABC

Abstract base class for design tool providers.

Source code in src/creational/factory.py 
44
45
46
47
48
49
50
class DesignToolProvider(ABC):
    """Abstract base class for design tool providers."""

    @abstractmethod
    def getDesignTool(self) -> DesignTool:
        """Returns an instance of a design tool."""
        pass

getDesignTool() abstractmethod

Returns an instance of a design tool.

Source code in src/creational/factory.py 
47
48
49
50
@abstractmethod
def getDesignTool(self) -> DesignTool:
    """Returns an instance of a design tool."""
    pass

FigmaProvider

Bases: DesignToolProvider

Concrete implementation of the DesignToolProvider interface for Figma.

Source code in src/creational/factory.py 
53
54
55
56
57
58
class FigmaProvider(DesignToolProvider):
    """Concrete implementation of the DesignToolProvider interface for Figma."""

    def getDesignTool(self) -> DesignTool:
        """Returns an instance of Figma."""
        return Figma()

getDesignTool()

Returns an instance of Figma.

Source code in src/creational/factory.py 
56
57
58
def getDesignTool(self) -> DesignTool:
    """Returns an instance of Figma."""
    return Figma()

AdobeXDProvider

Bases: DesignToolProvider

Concrete implementation of the DesignToolProvider interface for AdobeXD.

Source code in src/creational/factory.py 
61
62
63
64
65
66
class AdobeXDProvider(DesignToolProvider):
    """Concrete implementation of the DesignToolProvider interface for AdobeXD."""

    def getDesignTool(self) -> DesignTool:
        """Returns an instance of AdobeXD."""
        return AdobeXD()

getDesignTool()

Returns an instance of AdobeXD.

Source code in src/creational/factory.py 
64
65
66
def getDesignTool(self) -> DesignTool:
    """Returns an instance of AdobeXD."""
    return AdobeXD()

ZeplinProvider

Bases: DesignToolProvider

Concrete implementation of the DesignToolProvider interface for Zeplin.

Source code in src/creational/factory.py 
69
70
71
72
73
74
class ZeplinProvider(DesignToolProvider):
    """Concrete implementation of the DesignToolProvider interface for Zeplin."""

    def getDesignTool(self) -> DesignTool:
        """Returns an instance of Zeplin."""
        return Zeplin()

getDesignTool()

Returns an instance of Zeplin.

Source code in src/creational/factory.py 
72
73
74
def getDesignTool(self) -> DesignTool:
    """Returns an instance of Zeplin."""
    return Zeplin()

Designer

Class representing a designer who creates designs using a specific design tool.

Source code in src/creational/factory.py 
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
class Designer:
    """Class representing a designer who creates designs using a specific design tool."""

    _design_tool: DesignTool = None

    def __init__(self, designToolProvider: DesignToolProvider) -> None:
        """
        Initializes a Designer object with the provided design tool provider.

        Args:
            designToolProvider (DesignToolProvider): A provider of design tools.
        """
        self._design_tool = designToolProvider.getDesignTool()

    def createDesign(self) -> DesignTool:
        """
        Creates a design using the selected design tool.

        Returns:
            DesignTool: The design tool used to create the design.
        """
        return self._design_tool.createDesign()

__init__(designToolProvider)

Initializes a Designer object with the provided design tool provider.

Parameters:

Name Type Description Default
designToolProvider DesignToolProvider

A provider of design tools.

 required
Source code in src/creational/factory.py 
82
83
84
85
86
87
88
89
def __init__(self, designToolProvider: DesignToolProvider) -> None:
    """
    Initializes a Designer object with the provided design tool provider.

    Args:
        designToolProvider (DesignToolProvider): A provider of design tools.
    """
    self._design_tool = designToolProvider.getDesignTool()

createDesign()

Creates a design using the selected design tool.

Returns:

Name Type Description
DesignTool DesignTool

The design tool used to create the design.
Source code in src/creational/factory.py 
91
92
93
94
95
96
97
98
def createDesign(self) -> DesignTool:
    """
    Creates a design using the selected design tool.

    Returns:
        DesignTool: The design tool used to create the design.
    """
    return self._design_tool.createDesign()

main()

Steps to implement:

1. Create Provider's Instance

2. Create a Designer Instance by providing Provider's instance

3. Call the method using Designer's Instance

Source code in src/creational/factory.py 
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
def main():
    """
    **Steps to implement:**\n
    **1. Create Provider's Instance**\n
    **2. Create a Designer Instance by providing Provider's instance**\n
    **3. Call the method using Designer's Instance**\n
    """
    figma_provider = FigmaProvider()
    designer1 = Designer(figma_provider)
    print(f"Designer 1 {designer1.createDesign()}")

    adobeXD_provider = AdobeXDProvider()
    designer2 = Designer(adobeXD_provider)
    print(f"Designer 2 {designer2.createDesign()}")

    sketch_provider = ZeplinProvider()
    designer3 = Designer(sketch_provider)
    print(f"Designer 3 {designer3.createDesign()}")

Source Code

src/creational/factory.py
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
from abc import ABC, abstractmethod

class DesignTool(ABC):
    @abstractmethod
    def createDesign(self) -> None:
        pass


class Figma(DesignTool):
    def createDesign(self) -> None:
        return "creating a design using Figma!"


class AdobeXD(DesignTool):
    def createDesign(self) -> None:
        return "creating a design using AdobeXD!"


class Zeplin(DesignTool):
    def createDesign(self) -> None:
        return "creating a design using Zeplin!"


class DesignToolProvider(ABC):
    @abstractmethod
    def getDesignTool(self) -> DesignTool:
        pass


class FigmaProvider(DesignToolProvider):
    def getDesignTool(self) -> DesignTool:
        return Figma()


class AdobeXDProvider(DesignToolProvider):
    def getDesignTool(self) -> DesignTool:
        return AdobeXD()


class ZeplinProvider(DesignToolProvider):
    def getDesignTool(self) -> DesignTool:
        return Zeplin()


class Designer:
    _design_tool: DesignTool = None
    def __init__(self, designToolProvider: DesignToolProvider) -> None:
        self._design_tool = designToolProvider.getDesignTool()

    def createDesign(self) -> DesignTool:
        return self._design_tool.createDesign()


def main():
    figma_provider = FigmaProvider()
    designer1 = Designer(figma_provider)
    print(f"Designer 1 {designer1.createDesign()}")

    adobeXD_provider = AdobeXDProvider()
    designer2 = Designer(adobeXD_provider)
    print(f"Designer 2 {designer2.createDesign()}")

    sketch_provider = ZeplinProvider()
    designer3 = Designer(sketch_provider)
    print(f"Designer 3 {designer3.createDesign()}")


if __name__ == "__main__":
    main()

Class Diagram

classDiagram
    class DesignTool {
        createDesign()
    }
    class Figma {
        createDesign()
    }
    class AdobeXD {
        createDesign()
    }
    class Zeplin {
        createDesign()
    }
    class DesignToolProvider {
        getDesignTool()
    }
    class FigmaProvider {
        getDesignTool()
    }
    class AdobeXDProvider {
        getDesignTool()
    }
    class ZeplinProvider {
        getDesignTool()
    }
    class Designer {
        createDesign()
    }
    DesignTool <|-- DesignToolProvider
    Designer --|> DesignToolProvider
    DesignToolProvider --|> FigmaProvider
    DesignToolProvider --|> AdobeXDProvider
    DesignToolProvider --|> ZeplinProvider
    DesignTool --|> Figma
    DesignTool --|> AdobeXD
    DesignTool --|> Zeplin