Design patterns in PHP are reusable solutions to common software design problems. They are templates that provide a general structure for solving problems.
Examples of design patterns in PHP
- Singleton pattern
- Factory pattern
- Adapter pattern
- Facade pattern
- Decorator pattern
- Strategy pattern
- Observer pattern
- Command pattern
- Abstract Factory Pattern
- Prototype pattern
A detailed description of some important design patterns.
Singleton pattern
The singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system.
Example:
final class Singleton {
private static $instance = null;
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
private function __construct() {}
private function __clone() {}
private function __wakeup() {}
}
// Usage: $singleton = Singleton::getInstance()
$SingletonInstance = Singleton::getInstance();
$SingletonInstance->doSomething();
$SingletonInstance = Singleton::getInstance(); $SingletonInstance->doSomething();
The Singleton pattern ensures that only one instance of the Singleton class is created, and it is created lazily (i.e., when it is first requested). Subsequent calls to getInstance will always return the same instance.
Factory pattern
A factory pattern is a creational design pattern that allows a program to create objects without specifying their exact class. It provides a common interface for creating objects, which makes the code more flexible and easy to maintain. The factory pattern is commonly used in software development when a program needs to create objects of a certain type, but the exact type is not known until runtime. It is also used to encapsulate object creation logic within a separate class.
Example:
// Base interface for all products
interface Product {
function getName();
}
// Concrete product
class ConcreteProduct1 implements Product {
public function getName() {
return 'ConcreteProduct1';
}
}
// Concrete product
class ConcreteProduct2 implements Product {
public function getName() {
return 'ConcreteProduct2';
}
}
// Factory interface
interface ProductFactory {
function createProduct($productName);
}
// Concrete factory
class ConcreteProductFactory implements ProductFactory {
public function createProduct($productName) {
switch ($productName) {
case 'ConcreteProduct1':
return new ConcreteProduct1();
case 'ConcreteProduct2':
return new ConcreteProduct2();
}
}
}
$productFactory = new ConcreteProductFactory();
$product1 = $productFactory->createProduct('ConcreteProduct1');
$product2 = $productFactory->createProduct('ConcreteProduct2');
Facade pattern
The facade pattern is a software design pattern that provides a simplified interface to a complex system of components. It hides the complexity of the system and provides an easier way for clients to interact with the system. The facade pattern allows for more modular and decoupled code, making it easier to maintain and extend.
Example:
class Facade {
private $subsystem1;
private $subsystem2;
private $subsystem3;
public function __construct() {
$this->subsystem1 = new Subsystem1();
$this->subsystem2 = new Subsystem2();
$this->subsystem3 = new Subsystem3();
}
public function operation1() {
$this->subsystem1->operation1();
$this->subsystem2->operation1();
$this->subsystem3->operation1();
}
public function operation2() {
$this->subsystem1->operation2();
$this->subsystem2->operation2();
$this->subsystem3->operation2();
}
}
class Subsystem1 {
public function operation1() {
// implementation details
}
public function operation2() {
// implementation details
}
}
class Subsystem2 {
public function operation1() {
// implementation details
}
public function operation2() {
// implementation details
}
}
class Subsystem3 {
public function operation1() {
// implementation details
}
public function operation2() {
// implementation details
}
}
In this example, the Facade class acts as an interface to simplify the use of the underlying subsystems, which are represented by the Subsystem1, Subsystem2, and Subsystem3 classes. The Facade class provides a simplified interface for performing operations on the subsystems, and the underlying subsystems are not directly accessible from outside of the Facade.
Other Important Post
What is Solid Principle with Example?
PHP Interview questions and answers
Difference between Stored Procedure and Function in Mysql
Follow us for latest update YouTube and Facebook