├── Creational
    ├── Builder
    │   └── Builder.php
    ├── FactoryMethod
    │   └── FactoryMethod.php
    └── Singleton
    │   └── Singleton.php
├── LICENSE
└── README.md


/Creational/Builder/Builder.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 | |--------------------------------------------------------------------------
  5 | | Builder Design Pattern
  6 | |--------------------------------------------------------------------------
  7 | | Implement the Builder Design Pattern to create complex objects with 
  8 | | multiple steps. This pattern is useful when creating complex objects
  9 | | that require a controlled, step-by-step construction process.
 10 | | With the Builder pattern, different builders can create variations of 
 11 | | an object while using the same construction sequence.
 12 | |--------------------------------------------------------------------------
 13 | | @category  Design Pattern
 14 | | @package   Creational
 15 | | @version   1.0.0
 16 | | @license   MIT License
 17 | | @link      https://github.com/alirezajavadigit/Design-patterns
 18 | |--------------------------------------------------------------------------
 19 | */
 20 | 
 21 | namespace Creational\Builder;
 22 | 
 23 | /**
 24 |  * The Product class represents the complex object that will be built.
 25 |  * In this example, a House object with various components.
 26 |  */
 27 | class House
 28 | {
 29 |     // Different components of the house
 30 |     public array $walls = [];
 31 |     public array $doors = [];
 32 |     public array $windows = [];
 33 |     public ?string $roof = null;
 34 | 
 35 |     /**
 36 |      * Display the details of the house that has been built.
 37 |      */
 38 |     public function show(): void
 39 |     {
 40 |         echo "House with " . count($this->walls) . " walls, " . count($this->doors) . " doors, " . count($this->windows) . " windows, and a " . ($this->roof ? "$this->roof roof" : "no roof") . ".\n";
 41 |     }
 42 | }
 43 | 
 44 | /**
 45 |  * The Builder interface declares the methods necessary to build each part of the product.
 46 |  * These methods will be implemented by concrete builder classes.
 47 |  */
 48 | interface HouseBuilder
 49 | {
 50 |     public function buildWalls(): void;
 51 |     public function buildDoors(): void;
 52 |     public function buildWindows(): void;
 53 |     public function buildRoof(): void;
 54 |     public function getHouse(): House;
 55 | }
 56 | 
 57 | /**
 58 |  * Concrete Builder for building a Wooden House.
 59 |  * This class implements the HouseBuilder interface and defines specific steps to
 60 |  * construct a house with wooden components.
 61 |  */
 62 | class WoodenHouseBuilder implements HouseBuilder
 63 | {
 64 |     private House $house;
 65 | 
 66 |     /**
 67 |      * Initialize a new House object.
 68 |      */
 69 |     public function __construct()
 70 |     {
 71 |         $this->house = new House();
 72 |     }
 73 | 
 74 |     /**
 75 |      * Build wooden walls for the house.
 76 |      */
 77 |     public function buildWalls(): void
 78 |     {
 79 |         $this->house->walls = array_fill(0, 4, 'wooden wall');
 80 |     }
 81 | 
 82 |     /**
 83 |      * Build wooden doors for the house.
 84 |      */
 85 |     public function buildDoors(): void
 86 |     {
 87 |         $this->house->doors = array_fill(0, 2, 'wooden door');
 88 |     }
 89 | 
 90 |     /**
 91 |      * Build windows with wooden frames for the house.
 92 |      */
 93 |     public function buildWindows(): void
 94 |     {
 95 |         $this->house->windows = array_fill(0, 4, 'wooden-framed window');
 96 |     }
 97 | 
 98 |     /**
 99 |      * Add a wooden roof to the house.
100 |      */
101 |     public function buildRoof(): void
102 |     {
103 |         $this->house->roof = 'wooden';
104 |     }
105 | 
106 |     /**
107 |      * Return the fully constructed house object.
108 |      *
109 |      * @return House The constructed house.
110 |      */
111 |     public function getHouse(): House
112 |     {
113 |         return $this->house;
114 |     }
115 | }
116 | 
117 | /**
118 |  * Concrete Builder for building a Brick House.
119 |  * This class implements the HouseBuilder interface and defines specific steps to
120 |  * construct a house with brick and metal components.
121 |  */
122 | class BrickHouseBuilder implements HouseBuilder
123 | {
124 |     private House $house;
125 | 
126 |     /**
127 |      * Initialize a new House object.
128 |      */
129 |     public function __construct()
130 |     {
131 |         $this->house = new House();
132 |     }
133 | 
134 |     /**
135 |      * Build brick walls for the house.
136 |      */
137 |     public function buildWalls(): void
138 |     {
139 |         $this->house->walls = array_fill(0, 4, 'brick wall');
140 |     }
141 | 
142 |     /**
143 |      * Build a metal door for the house.
144 |      */
145 |     public function buildDoors(): void
146 |     {
147 |         $this->house->doors = array_fill(0, 1, 'metal door');
148 |     }
149 | 
150 |     /**
151 |      * Build windows with brick frames for the house.
152 |      */
153 |     public function buildWindows(): void
154 |     {
155 |         $this->house->windows = array_fill(0, 6, 'brick-framed window');
156 |     }
157 | 
158 |     /**
159 |      * Add a metal roof to the house.
160 |      */
161 |     public function buildRoof(): void
162 |     {
163 |         $this->house->roof = 'metal';
164 |     }
165 | 
166 |     /**
167 |      * Return the fully constructed house object.
168 |      *
169 |      * @return House The constructed house.
170 |      */
171 |     public function getHouse(): House
172 |     {
173 |         return $this->house;
174 |     }
175 | }
176 | 
177 | /**
178 |  * The Director class is responsible for controlling the building process.
179 |  * It accepts a builder object and calls its methods in a specific sequence
180 |  * to construct the complex object.
181 |  */
182 | class HouseDirector
183 | {
184 |     private HouseBuilder $builder;
185 | 
186 |     /**
187 |      * Set the builder object that will be used for constructing the house.
188 |      *
189 |      * @param HouseBuilder $builder The builder responsible for construction.
190 |      */
191 |     public function setBuilder(HouseBuilder $builder): void
192 |     {
193 |         $this->builder = $builder;
194 |     }
195 | 
196 |     /**
197 |      * Direct the construction process by calling each build step in sequence.
198 |      *
199 |      * @return House The completed house.
200 |      */
201 |     public function constructHouse(): House
202 |     {
203 |         $this->builder->buildWalls();
204 |         $this->builder->buildDoors();
205 |         $this->builder->buildWindows();
206 |         $this->builder->buildRoof();
207 |         return $this->builder->getHouse();
208 |     }
209 | }
210 | 
211 | // Client Code
212 | // Demonstrates the usage of the Builder pattern to construct different types of houses.
213 | 
214 | $director = new HouseDirector();
215 | 
216 | // Building a wooden house
217 | $woodenHouseBuilder = new WoodenHouseBuilder();
218 | $director->setBuilder($woodenHouseBuilder);
219 | $woodenHouse = $director->constructHouse();
220 | $woodenHouse->show(); // Outputs: House with 4 walls, 2 doors, 4 windows, and a wooden roof.
221 | 
222 | // Building a brick house
223 | $brickHouseBuilder = new BrickHouseBuilder();
224 | $director->setBuilder($brickHouseBuilder);
225 | $brickHouse = $director->constructHouse();
226 | $brickHouse->show(); // Outputs: House with 4 walls, 1 door, 6 windows, and a metal roof.
227 | 


--------------------------------------------------------------------------------
/Creational/FactoryMethod/FactoryMethod.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 | |--------------------------------------------------------------------------
  5 | | Factory Method Design Pattern
  6 | |--------------------------------------------------------------------------
  7 | | Implement Factory Method Design Pattern to create objects without specifying
  8 | | the exact class of object that will be created.
  9 | |--------------------------------------------------------------------------
 10 | | @category  Design Pattern
 11 | | @package   Creational
 12 | | @author    Alireza Javadi
 13 | | @version   1.0.0
 14 | | @license   MIT License
 15 | | @link      https://github.com/alirezajavadigit/Design-patterns
 16 | |--------------------------------------------------------------------------
 17 | */
 18 | 
 19 | namespace Creational\FactoryMethod;
 20 | 
 21 | /**
 22 |  * Interface FactoryMethod
 23 |  *
 24 |  * This interface declares a method that all concrete products must implement.
 25 |  * The method 'action' is expected to perform an action and return a string.
 26 |  */
 27 | interface FactoryMethod
 28 | {
 29 |     /**
 30 |      * Perform an action and return a string.
 31 |      *
 32 |      * @return string A string indicating the action completion.
 33 |      */
 34 |     public function action(): string;
 35 | }
 36 | 
 37 | /**
 38 |  * Class ConcreteFactoryMethod
 39 |  *
 40 |  * This class implements the FactoryMethod interface. It defines the action method
 41 |  * to perform a specific task and return a confirmation string.
 42 |  */
 43 | class ConcreteFactoryMethod implements FactoryMethod
 44 | {
 45 |     /**
 46 |      * Perform an action and return a string indicating action completion.
 47 |      *
 48 |      * @return string A string that confirms the action is completed.
 49 |      */
 50 |     public function action(): string
 51 |     {
 52 |         return "action completed";
 53 |     }
 54 | }
 55 | 
 56 | /**
 57 |  * Abstract Class Creator
 58 |  *
 59 |  * This abstract class declares the factory method that returns an object of type FactoryMethod.
 60 |  * It also includes a concrete method 'otherAction' that performs some other actions.
 61 |  */
 62 | abstract class Creator
 63 | {
 64 |     /**
 65 |      * The factory method that must be implemented by concrete subclasses.
 66 |      * This method should return an instance of a class that implements the FactoryMethod interface.
 67 |      *
 68 |      * @return FactoryMethod An instance of a class that implements FactoryMethod.
 69 |      */
 70 |     abstract public function factoryMethod(): FactoryMethod;
 71 | 
 72 |     /**
 73 |      * Perform some other actions and return an array of strings.
 74 |      *
 75 |      * @return array An array containing two strings: "other" and "action".
 76 |      */
 77 |     public function otherAction(): array
 78 |     {
 79 |         return ["other", "action"];
 80 |     }
 81 | }
 82 | 
 83 | /**
 84 |  * Class ConcreteCreator
 85 |  *
 86 |  * This class extends the abstract Creator class and implements the factoryMethod.
 87 |  * The factoryMethod returns an instance of ConcreteFactoryMethod.
 88 |  */
 89 | class ConcreteCreator extends Creator
 90 | {
 91 |     /**
 92 |      * Implementation of the factoryMethod that returns an instance of ConcreteFactoryMethod.
 93 |      *
 94 |      * @return FactoryMethod An instance of ConcreteFactoryMethod.
 95 |      */
 96 |     public function factoryMethod(): FactoryMethod
 97 |     {
 98 |         return new ConcreteFactoryMethod();
 99 |     }
100 | }
101 | 
102 | /**
103 |  * Function creator
104 |  *
105 |  * This function takes a Creator object as an argument and calls its otherAction method.
106 |  * It returns the result of the otherAction method.
107 |  *
108 |  * @param Creator $creator An instance of a class that extends Creator.
109 |  * @return array The result of calling the otherAction method on the Creator object.
110 |  */
111 | function creator(Creator $creator)
112 | {
113 |     return $creator->otherAction();
114 | }
115 | 
116 | // Example usage of the Factory Method Design Pattern.
117 | // Create an instance of ConcreteCreator and pass it to the creator function.
118 | // Print the result of the otherAction method called on the ConcreteCreator instance.
119 | print_r(creator(new ConcreteCreator()));
120 | 


--------------------------------------------------------------------------------
/Creational/Singleton/Singleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Singleton Design Pattern
 6 | |--------------------------------------------------------------------------
 7 | | Implement Singleton Design Pattern to ensure a class has only one instance 
 8 | | and provide a global point of access to it.
 9 | |--------------------------------------------------------------------------
10 | | @category  Design Pattern
11 | | @package   Creational
12 | | @version   1.0.0
13 | | @author    Alireza Javadi
14 | | @license   MIT License
15 | | @link      https://github.com/alirezajavadigit/Design-patterns
16 | |--------------------------------------------------------------------------
17 | */
18 | 
19 | namespace Creational\Singleton;
20 | 
21 | class Singleton
22 | {
23 |     /**
24 |      * The singleton instance of the class.
25 |      *
26 |      * @var self|null The singleton instance of the class.
27 |      */
28 |     private static $instance = null;
29 | 
30 |     /**
31 |      * Lock for thread safety.
32 |      * 
33 |      * @var mixed Lock for thread safety.
34 |      */
35 |     private static $lock = null;
36 | 
37 |     /**
38 |      * Constructor method is private to prevent direct instantiation of the class.
39 |      * 
40 |      * This constructor method is made private to prevent external instantiation 
41 |      * of the class. It ensures that the class can only be instantiated from 
42 |      * within itself, which is essential for implementing the Singleton pattern.
43 |      */
44 |     private function __construct()
45 |     {
46 |         // Initialize lock
47 |         if (is_null(self::$lock)) {
48 |             self::$lock = new \stdClass();
49 |         }
50 |     }
51 | 
52 |     /**
53 |      * Prevent instance from being cloned.
54 |      */
55 |     private function __clone()
56 |     {
57 |     }
58 | 
59 |     /**
60 |      * Prevent instance from being unserialized.
61 |      */
62 |     private function __wakeup()
63 |     {
64 |     }
65 | 
66 |     /**
67 |      * Get the singleton instance of the class.
68 |      *
69 |      * @return self The singleton instance of the class.
70 |      * 
71 |      * This method returns the singleton instance of the class. If the instance 
72 |      * does not exist, it creates a new one and assigns it to the static 
73 |      * property $instance. This ensures that only one instance of the class is 
74 |      * created throughout the application's lifecycle.
75 |      */
76 |     public static function getInstance(): self
77 |     {
78 |         if (is_null(self::$instance)) {
79 |             // Thread-safe lazy initialization
80 |             $lock = self::$lock; // to ensure thread safety
81 |             if (is_null(self::$instance)) {
82 |                 self::$instance = new self();
83 |             }
84 |         }
85 | 
86 |         return self::$instance;
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 alireza javadi
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Design-patterns
2 | In this project, I will provide examples of all major design patterns and demonstrate how they are implemented in PHP.
3 | 


--------------------------------------------------------------------------------