Merge branch 'master' of https://github.com/Sean-Bradley/Design-Patterns-In-Python

Author: Sean-Bradley

README.md

@@ -35,26 +35,30 @@ You will learn these Design Patterns
     * Template
     * Visitor
 
-<!--
-Register for the course at Skillshare. https://skl.sh/34SM2Xg **(Get Extra 2 Months Premium Membership Free)**
--->
+
+Register for the course at 
+- [Skillshare](https://skl.sh/34SM2Xg) **(Get Extra 2 Months Premium Membership Free)**
+- [Udemy](https://www.udemy.com/course/design-patterns-in-python/?referralCode=7493DBBBF97FF2B0D24D) **(New Student Discount)**
+
 
 ## Introduction Video
 
 [![Design Patterns in Python Introduction](https://img.youtube.com/vi/OOxyTUWsY7A/0.jpg)](https://youtu.be/OOxyTUWsY7A)
 
 
-<!--
-To register for this course visit
 
-<a href="https://skl.sh/34SM2Xg" target="_blank"><img src="https://github.com/img/skillshare_btn.png" title="Skillshare 2 Months Free Premium Membership"/></a>
+To register for this course visit
 
-<b>
-* Get 2 Months Free Premium Membership to 1000s of Courses <br>
-* Full Lifetime Access <br/>
-* Subscription Model <br/>
-* Cancel Any Time</b>
--->
+<a href="https://skl.sh/34SM2Xg" target="_blank"><img src="img/skillshare_btn.png" title="Skillshare 2 Months Free Premium Membership"/></a>
 
+- Get 2 Months Free Premium Membership to 1000s of Courses
+- Full Lifetime Access
+- Subscription Model
+- Cancel Any Time
 
+<a href="https://www.udemy.com/course/design-patterns-in-python/?referralCode=7493DBBBF97FF2B0D24D" target="_blank"><img src="img/udemy_btn.png" title="Udemy Design Patterns in Python"/></a>
 
+- One Time Payment
+- Full Lifetime Access
+- Certificate of Completion
+- 30 Day Money-Back Guarantee

docs/CNAME

@@ -0,0 +1 @@
+designpatterns.seanwasere.com

docs/abstract_factory.md

@@ -0,0 +1,58 @@
+# Abstract Factory Design Pattern
+
+The Abstract Factory Pattern adds an abstract layer over multiple factory method implementations.
+
+The Abstract Factory contains or composites one or more than one factory method
+
+![Abstract Factory Overview](abstract_factory.png)
+
+Abstract Factory in the context of a Furniture factory
+![Abstract Factory in context](abstract_factory_furniture.png)
+
+
+Import existing factories
+```python
+from chair_factory import ChairFactory
+from table_factory import TableFactory
+```
+
+Create an interface
+```python
+class IFurnitureFactory(metaclass=ABCMeta): 
+    """Furniture Factory Interface"""
+
+    @abstractstaticmethod
+    def get_furniture(furniture):
+        """The static funiture factory interface method"""
+```
+
+The factories abstract static method which delegates to the correct factory
+```python
+
+class FurnitureFactory(IFurnitureFactory):  
+    """The Furniture Factory Concrete Class"""
+
+    @staticmethod
+    def get_furniture(furniture):
+        """Static get_furniture method"""
+        try:
+            if furniture in ["SmallChair", "MediumChair", "BigChair"]:
+                return ChairFactory().get_chair(furniture)
+            if furniture in ["SmallTable", "MediumTable", "BigTable"]:
+                return TableFactory().get_table(furniture)
+            raise AssertionError("No Furniture Factory Found")
+        except AssertionError as _e:
+            print(_e)
+        return None
+```
+
+
+Requesting from the abstract factory at run time
+```python
+if __name__ == "__main__":
+    FURNITURE = FurnitureFactory.get_furniture("SmallChair")
+    print(f"{FURNITURE.__class__} : {FURNITURE.dimensions()}")
+
+    FURNITURE = FurnitureFactory.get_furniture("MediumTable")
+    print(f"{FURNITURE.__class__} : {FURNITURE.dimensions()}")
+```

docs/abstract_factory.png

@@ -0,0 +1,17 @@
+# Adapter Design Pattern
+
+The adapter design pattern solves these problems:
+
+- How can a class be reused that does not have an interface that a client requires?
+- How can classes that have incompatible interfaces work together?
+- How can an alternative interface be provided for a class?
+
+In this lecture, I have 2 classes, they don't share the same interface. The client requires it's objects to use an already standardised interface.
+
+So we need to create an adapter, that wraps the incompatible object, but implements the standardised interface.
+
+## Two Incompatible Classes
+![Adapter Design Pattern](adapter_before.png)
+
+## After Creating an Adapter
+![Adapter Design Pattern](adapter.png)

docs/abstract_factory_furniture.png

@@ -0,0 +1,21 @@
+# Builder Design Pattern
+
+The Builder Pattern is a creational pattern whose intent is to separate the construction of a complex object from its representation so that you can use the same construction process to create different representations.
+
+The Builder Pattern tries to solve,
+- How can a class create different representations of a complex object?
+- How can a class that includes creating a complex object be simplified?
+
+The Builder and Factory patterns are very similar in the fact they both instantiate new objects at run time. The difference is when the process of creating the object is more complex, so rather than the Factory returning a new instance of `ObjectA`, it could call the builders director construct method `ObjectA.construct()`. Both return an Object.
+
+Parts of the Builder Pattern
+1. **Product** - The Product being built
+2. **Concrete Builder** - Build the concrete product. Implements the IBuilder interface
+3. **Builder Interface** - The Interface which the Concrete builder should implement
+4. **Director** - Has a construct method which when called creates a customised product
+
+![Builder Pattern Overview](builder.png)
+
+The Builder Pattern in the context of a House Builder. There are multiple directors creating there own complex objects
+
+![Builder Pattern in Context](house_builder.png).