Merge pull request #5 from lemanh99/develop

Creational Design Patterns

Author: lemanh99

.gitignore

@@ -157,4 +157,4 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/

README.md

@@ -1 +1,68 @@
-# design-pattern
+## Design Pattern With Python
+
+Source: https://refactoring.guru/
+
+Email: [email protected]
+
+## Catalog of Design Pattern
+
+1. [Creational Design Patterns](creational-design-pattern)
+    - [Factory Method](creational-design-pattern/factory-method)
+    - [Abstract Factory](creational-design-pattern/abstract-factory)
+    - [Builder](creational-design-pattern/builder)
+    - [Prototype](creational-design-pattern/prototype)
+    - [Singleton](creational-design-pattern/singleton)
+2. Structural Design Patterns
+    - Adapter
+    - Bridge
+    - Composite
+    - Decorator
+    - Facade
+    - Flyweight
+    - Proxy
+3. Behavior Design Patterns
+    - Chain of Responsibility
+    - Command
+    - Iterator
+    - Mediator
+    - Memento
+    - Observer
+    - State
+    - Strategy
+    - Template Method
+    - Visitor
+
+## Directory
+
+```
+$ Design Pattern
+.
+├── ceational-design-pattern
+│   ├── factory-method
+│       ├── README.md
+│       ├── README-VI.md
+│       ├── main.py
+│       ├── example.py
+│   ├── abstract-method
+│       ├── README.md
+│       ├── README-VI.md
+│       ├── main.py
+│       ├── example.py
+│   ├── builder
+│       ├── README.md
+│       ├── README-VI.md
+│       ├── main.py
+│       ├── example.py
+│   ├── prototype
+│       ├── README.md
+│       ├── README-VI.md
+│       ├── main.py
+│       ├── example.py
+│   ├── singleton
+│       ├── README.md
+│       ├── README-VI.md
+│       ├── main.py
+│       ├── example.py
+└── README.md
+```
+

SOLID/__init__.py

@@ -0,0 +1,7 @@
+| Design Pattern                       | Định Nghĩa                                                                                             | Mục Đích Sử Dụng                                                                                      | Cách Sử Dụng                                                                                                                                                |
+|--------------------------------------|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Factory Method](factory-method)     | Cung cấp interface để tạo đối tượng, cho phép lớp con quyết định loại đối tượng cụ thể sẽ được tạo ra. | - Độc lập với lớp con cụ thể. - Mở rộng dễ dàng bằng cách thêm lớp con mới.                           | Định nghĩa giao diện hoặc lớp trừu tượng chứa Factory Method, sau đó triển khai Factory Method trong các lớp con.                                           |
+| [Abstract Factory](abstract-factory) | Cung cấp interface để tạo các "families(họ)" đối tượng liên quan mà không cần biết lớp cụ thể nào.     | - Duy trì tính nhất quán giữa các đối tượng liên quan.                                                | Định nghĩa giao diện hoặc lớp trừu tượng cho Abstract Factory, sau đó triển khai interface này trong các lớp con.                                           |
+| [Builder](builder)                   | Cho phép xây dựng đối tượng phức tạp step by step.                                                     | - Xây dựng đối tượng với nhiều thuộc tính hoặc tùy chọn khác nhau.                                    | Tạo một lớp Builder cho đối tượng cần xây dựng, định nghĩa phương thức để thiết lập thuộc tính hoặc tùy chọn, và triển khai phương thức xây dựng đối tượng. |
+| [Prototype](prototype)               | Cho phép tạo đối tượng mới bằng cách sao chép đối tượng đã tồn tại.                                    | - Tạo nhiều bản sao của một đối tượng mà không cần tạo lại từ đầu.                                    | Định nghĩa phương thức sao chép đối tượng hoặc triển khai interface Cloneable (nếu có).                                                                     |
+| [Singleton](singleton)               | Đảm bảo rằng chỉ có một đối tượng duy nhất của một lớp và cung cấp điểm truy cập toàn cục đến nó.      | - Đảm bảo rằng chỉ có một phiên bản duy nhất của một lớp. - Chia sẻ đối tượng trong toàn bộ ứng dụng. | Triển khai lớp Singleton bằng cách đảm bảo rằng constructor là private và cung cấp một phương thức tĩnh để truy cập đối tượng Singleton.                    |

creational-design-pattern/README-VI.md

@@ -0,0 +1,7 @@
+| Design Pattern                       | Definition                                                                                                                           | Purpose of Use                                                                          | How to Use                                                                                                                                                           |
+|--------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Factory Method](factory-method)     | Provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. | - Decouple from specific subclasses. - Easily extend by adding new subclasses.          | Define an interface or abstract class containing the Factory Method, then implement the Factory Method in the subclasses.                                            |
+| [Abstract Factory](abstract-factory) | Provides an interface for creating families of related or dependent objects without specifying their concrete classes.               | - Maintain consistency among related objects.                                           | Define an interface or abstract class for the Abstract Factory, then implement this interface in concrete classes.                                                   |
+| [Builder](builder)                   | Allows constructing a complex object step by step.                                                                                   | - Build objects with multiple attributes or options.                                    | Create a Builder class for the object to be constructed, define methods for setting attributes or options, and implement a build method for constructing the object. |
+| [Prototype](prototype)               | Allows creating new objects by copying an existing object.                                                                           | - Create multiple copies of an object without recreating it from scratch.               | Define a copy method for object copying or implement the Cloneable interface (if available).                                                                         |
+| [Singleton](singleton)               | Ensures that a class has only one instance and provides a global point of access to it.                                              | - Ensure only one instance of a class. - Share the instance throughout the application. | Implement the Singleton class by ensuring the constructor is private and providing a static method to access the Singleton instance.                                 |

creational-design-pattern/README.md

@@ -0,0 +1,72 @@
+## Source
+
+https://refactoring.guru/design-patterns/abstract-method
+
+## Cốt lõi:
+
+> Abstract Factory là một mẫu thiết kế sáng tạo cho phép bạn tạo ra các families của các đối tượng liên quan mà không
+> cần chỉ định cụ thể lớp của chúng.
+
+## Structure
+
+![alt tag](abstract_factory.png)
+
+Các bước tạo abstract method chính:
+
+1. **Xác định một lớp trừu tượng (abstract class):** Đầu tiên, bạn cần tạo một lớp trừu tượng (abstract class). Lớp này
+   sẽ chứa các abstract method mà các lớp con sau này phải triển khai.
+2. **Khai báo abstract method:** Trong lớp trừu tượng, bạn khai báo các abstract method bằng cách sử dụng từ khóa
+   abstract trước phương thức mà bạn muốn là abstract. Điều này sẽ định nghĩa phương thức mà các lớp con phải triển
+   khai. Abstract method không có thân phương thức (body) và chỉ có khai báo phương thức.
+3. **Triển khai abstract method trong các lớp con:** Các lớp con kế thừa từ lớp trừu tượng sẽ phải triển khai (
+   implement) các abstract method được định nghĩa trong lớp trừu tượng. Điều này bắt buộc các lớp con phải cung cấp một
+   triển khai cụ thể cho mỗi abstract method.
+
+## Description
+
+### Mục đích
+
+Mục đích của abstract method trong design pattern là tạo ra một interface chung cho các lớp con để chúng có thể triển
+khai theo cách riêng biệt, tùy chỉnh cho nhu cầu cụ thể của từng lớp con. Abstract method là một phần quan trọng của các
+mẫu thiết kế (design patterns) như Factory Method Pattern, Template Method Pattern và Strategy Pattern.
+
+Các lợi ích chính của việc sử dụng abstract method trong design pattern bao gồm:
+
+1. **Tách rời các phần của hệ thống:** Abstract method cho phép bạn xác định các phần của hệ thống mà các lớp con cần
+   triển khai. Điều này giúp tách rời các phần của hệ thống, giúp dễ dàng thay đổi hoặc mở rộng chúng mà không làm ảnh
+   hưởng đến các phần khác.
+2. **Tích hợp linh hoạt:** Các lớp con có thể triển khai abstract method theo cách riêng biệt, cho phép tích hợp các
+   phần mềm dễ dàng theo nhiều cách khác nhau mà không cần thay đổi mã nguồn của các lớp cha.
+3. **Tạo ra các mẫu chung:** Abstract method giúp xác định các mẫu chung trong các hệ thống phức tạp. Chúng là một phần
+   quan trọng của các mẫu thiết kế, giúp tạo ra cách tiếp cận chung cho việc giải quyết các vấn đề cụ thể.
+4. **Mở rộng và bảo trì dễ dàng:** Abstract method cho phép bạn thêm mới các lớp con mà không cần thay đổi mã nguồn của
+   các lớp cha, giúp dễ dàng mở rộng và bảo trì hệ thống.
+
+Tóm lại, abstract method là một cơ chế quan trọng trong design pattern để giúp tạo ra các hệ thống linh hoạt, dễ bảo trì
+và mở rộng.
+
+## Khi nào thì sử dụng abstract method
+
+1. **Khi bạn muốn định nghĩa một interface chung:** Khi có một nhóm lớp có cùng một interface chung, nhưng mỗi lớp con
+   có cách triển khai riêng biệt, bạn có thể sử dụng abstract methods để định nghĩa interface và yêu cầu các lớp con
+   triển khai các phương thức cụ thể.
+2. **Khi bạn muốn áp dụng mẫu thiết kế Factory Method:** Factory Method Pattern sử dụng abstract methods để tạo đối
+   tượng mà lớp cha không thể biết trước cụ thể lớp con nào cần được tạo.
+3. **Khi bạn muốn sử dụng Template Method Pattern:** Template Method Pattern sử dụng abstract method để xác định các
+   bước cơ bản trong một thuật toán và để các lớp con triển khai các phần cụ thể của thuật toán.
+4. **Khi bạn muốn sử dụng Strategy Pattern:** Strategy Pattern sử dụng abstract method để định nghĩa một loạt các thuật
+   toán và cho phép lựa chọn thuật toán cụ thể trong runtime.
+5. **Khi bạn muốn tạo các lớp cơ sở (base classes) không hoàn chỉnh:** Abstract methods cho phép bạn tạo các lớp cơ sở
+   mà không cung cấp triển khai cụ thể cho một số phương thức, để bắt buộc các lớp con triển khai chúng.
+6. **Khi bạn muốn đảm bảo tính đồng nhất và tuân thủ trong hệ thống:** Abstract methods giúp đảm bảo rằng các lớp con
+   phải triển khai các phương thức cụ thể, từ đó đảm bảo tính đồng nhất và tuân thủ trong hệ thống.
+
+Tóm lại, bạn nên sử dụng Factory Method khi cần tạo đối tượng một cách linh hoạt, duy trì tính linh hoạt trong ứng dụng
+và giảm sự phụ thuộc vào lớp cụ thể.
+
+## Running
+
+```
+python main.py
+python example.py
+```

creational-design-pattern/abstract-factory/README-VI.md

@@ -0,0 +1,33 @@
+## Source
+
+https://refactoring.guru/design-patterns/abstract-factory
+
+### Important:
+
+> 1. Abstract Factory is a creational design pattern that lets you produce families of related objects without
+     specifying their concrete classes.
+>
+> 2. Creates an instance of several families of classes
+
+## Description
+
+## Structure
+
+![alt tag](abstract_factory.png)
+
+## How to use
+
+1. Use the Abstract Factory when your code needs to work with various families of related products, but you don’t want
+   it to depend on the concrete classes of those products—they might be unknown beforehand or you simply want to allow
+   for future extensibility.
+2. Consider implementing the Abstract Factory when you have a class with a set of Factory Methods that blur its primary
+   responsibility.
+
+## How to implement
+https://refactoring.guru/design-patterns/abstract-factory#checklist
+## Running
+
+```
+python main.py
+python example.py
+```

creational-design-pattern/abstract-factory/README.md

@@ -0,0 +1,86 @@
+from abc import ABC, abstractmethod
+
+
+class Button(ABC):
+    @abstractmethod
+    def render(self):
+        pass
+
+
+class WinButton(Button):
+    def render(self):
+        print("WinButton: Render a button in a Windows style.")
+
+
+class MacButton(Button):
+    def render(self):
+        print("MacButton: Render a button in a Mac style.")
+
+
+class Checkbox(ABC):
+    @abstractmethod
+    def render(self):
+        pass
+
+
+class WinCheckbox(Checkbox):
+    def render(self):
+        print("WinCheckbox: Render a checkbox in a Windows style.")
+
+
+class MacCheckbox(Checkbox):
+    def render(self):
+        print("MacCheckbox: Render a checkbox in a Mac style.")
+
+
+class GUIFactory(ABC):
+    @abstractmethod
+    def create_button(self):
+        pass
+
+    @abstractmethod
+    def create_checkbox(self):
+        pass
+
+
+class WinFactory(GUIFactory):
+    def create_button(self):
+        return WinButton()
+
+    def create_checkbox(self):
+        return WinCheckbox()
+
+
+class MacFactory(GUIFactory):
+    def create_button(self):
+        return MacButton()
+
+    def create_checkbox(self):
+        return MacCheckbox()
+
+
+class Application(ABC):
+    def __init__(self, factory: GUIFactory):
+        self._factory = factory
+        self.button = None
+        self.checkbox = None
+
+    def create_ui(self):
+        self.button = self._factory.create_button()
+        self.checkbox = self._factory.create_checkbox()
+
+    def paint(self):
+        self.button.render()
+        self.checkbox.render()
+
+
+if __name__ == "__main__":
+    print("Configuring Windows application...")
+    application = Application(WinFactory())
+    application.create_ui()
+    application.paint()
+
+    print("Configuring Mac application...")
+    application = Application(MacFactory())
+    application.create_ui()
+    application.paint()

creational-design-pattern/abstract-factory/abstract_factory.png

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractProductA(ABC):
+    @abstractmethod
+    def useful_func_a(self) -> str:
+        pass
+
+
+class ConcreteProductA1(AbstractProductA):
+    def useful_func_a(self) -> str:
+        return "ConcreteProductA1: The result of the product A1."
+
+
+class ConcreteProductA2(AbstractProductA):
+
+    def useful_func_a(self) -> str:
+        return "ConcreteProductA2: The result of the product A2."
+
+
+class AbstractProductB(ABC):
+    @abstractmethod
+    def useful_func_b(self) -> str:
+        pass
+
+    @abstractmethod
+    def another_useful_func_b(self, collaborator: AbstractProductA) -> None:
+        pass
+
+
+class ConcreteProductB1(AbstractProductB):
+    def useful_func_b(self) -> str:
+        return "ConcreteProductB1: The result of the product B1."
+
+    def another_useful_func_b(self, collaborator: AbstractProductA) -> str:
+        result = collaborator.useful_func_a()
+        return f"The result of the B1 collaborating with: ({result})"
+
+
+class ConcreteProductB2(AbstractProductB):
+    def useful_func_b(self) -> str:
+        return "ConcreteProductB2: The result of the product B2."
+
+    def another_useful_func_b(self, collaborator: AbstractProductA) -> str:
+        result = collaborator.useful_func_a()
+        return f"The result of the B2 collaborating with: ({result})"
+
+
+class AbstractFactory(ABC):
+    @abstractmethod
+    def create_product_a(self) -> AbstractProductA:
+        pass
+
+    @abstractmethod
+    def create_product_b(self) -> AbstractProductB:
+        pass
+
+
+class ConcreteFactory1(AbstractFactory):
+    def create_product_a(self) -> AbstractProductA:
+        return ConcreteProductA1()
+
+    def create_product_b(self) -> AbstractProductB:
+        return ConcreteProductB1()
+
+
+class ConcreteFactory2(AbstractFactory):
+    def create_product_a(self) -> AbstractProductA:
+        return ConcreteProductA2()
+
+    def create_product_b(self) -> AbstractProductB:
+        return ConcreteProductB2()
+
+
+class ClientCode:
+    def __init__(self, factory: AbstractFactory) -> None:
+        self._factory = factory
+
+    def some_operation(self) -> None:
+        product_a = self._factory.create_product_a()
+        product_b = self._factory.create_product_b()
+
+        print(f"{product_b.useful_func_b()}")
+        print(f"{product_b.another_useful_func_b(product_a)}", end="")
+
+
+if __name__ == "__main__":
+    print("Client: Testing client code with the first factory type:")
+    ClientCode(ConcreteFactory1()).some_operation()
+    print("\n")
+
+    print("Client: Testing the same client code with the second factory type:")
+    ClientCode(ConcreteFactory2()).some_operation()