<?php
// Define a class with a private constructor
class Database {
  // Declare a static property to hold the single instance
  private static $instance = null;
  // Declare a private constructor to prevent creating new instances
  private function __construct() {
    // Connect to the database here
  }
  // Declare a public static method to get the single instance
  public static function getInstance() {
    // Check if the instance is null
    if (self::$instance == null) {
      // Create a new instance and assign it to the property
      self::$instance = new Database();
    }
    // Return the instance
    return self::$instance;
  }
}
// Get the single instance of the Database class
$db = Database::getInstance();
// Use the instance as needed
$db->query("SELECT * FROM users");

<?php
// Define an abstract interface for shapes
interface Shape {
  // Declare an abstract method to draw the shape
  public function draw();
}
// Define a concrete class for circles that implements the Shape interface
class Circle implements Shape {
  // Declare a property to store the radius
  private $radius;
  // Declare a constructor to initialize the radius
  public function __construct($radius) {
    $this->radius = $radius;
  }
  // Implement the draw method to print the circle
  public function draw() {
    echo "Drawing a circle with radius " . $this->radius . "\n";
  }
}
// Define a concrete class for squares that implements the Shape interface
class Square implements Shape {
  // Declare a property to store the side length
  private $side;
  // Declare a constructor to initialize the side length
  public function __construct($side) {
    $this->side = $side;
  }
  // Implement the draw method to print the square
  public function draw() {
    echo "Drawing a square with side length " . $this->side . "\n";
  }
}
// Define a static method to create and return shapes based on a parameter
class ShapeFactory {
  // Declare a static method that takes a shape name and an optional size as parameters
  public static function createShape($name, $size = 1) {
    // Switch on the shape name
    switch ($name) {
      // If it is circle, return a new Circle object with the size as radius
      case "circle":
        return new Circle($size);
      // If it is square, return a new Square object with the size as side length
      case "square":
        return new Square($size);
      // If it is anything else, throw an exception
      default:
        throw new Exception("Invalid shape name: " . $name);
    }
  }
}
// Use the factory method to create and use different shapes
$circle = ShapeFactory::createShape("circle", 2);
$square = ShapeFactory::createShape("square", 3);
$circle->draw();
$square->draw();

<?php
// Define an interface for subjects
interface Subject {
  // Declare a method to attach an observer to the subject
  public function attach(Observer $observer);
  // Declare a method to detach an observer from the subject
  public function detach(Observer $observer);
  // Declare a method to notify all the observers of a state change
  public function notify();
}
// Define an interface for observers
interface Observer {
  // Declare a method to update the observer with the new state of the subject
  public function update(Subject $subject);
}
// Define a concrete class for newsletters that implements the Subject interface
class Newsletter implements Subject {
  // Declare a property to store the list of observers
  private $observers = array();
  // Declare a property to store the latest news
  private $news;
  // Implement the attach method to add an observer to the list
  public function attach(Observer $observer) {
    $this->observers[] = $observer;
  }
  // Implement the detach method to remove an observer from the list
  public function detach(Observer $observer) {
    $key = array_search($observer, $this->observers, true);
    if ($key !== false) {
      unset($this->observers[$key]);
    }
  }
  // Implement the notify method to loop through the list and call the update method on each observer
  public function notify() {
    foreach ($this->observers as $observer) {
      $observer->update($this);
    }
  }
  // Declare a method to set the latest news and notify the observers
  public function setNews($news) {
    $this->news = $news;
    $this->notify();
  }
  // Declare a method to get the latest news
  public function getNews() {
    return $this->news;
  }
}
// Define a concrete class for email subscribers that implements the Observer interface
class EmailSubscriber implements Observer {
  // Declare a property to store the email address
  private $email;
  // Declare a constructor to initialize the email address
  public function __construct($email) {
    $this->email = $email;
  }
  // Implement the update method to print the email address and the latest news from the subject
  public function update(Subject $subject) {
    echo "Sending email to " . $this->email . " with news: " . $subject->getNews() . "\n";
  }
}
// Create a new newsletter object
$newsletter = new Newsletter();
// Create some email subscriber objects and attach them to the newsletter object
$subscriber1 = new EmailSubscriber("alice@example.com");
$subscriber2 = new EmailSubscriber("bob@example.com");
$subscriber3 = new EmailSubscriber("charlie@example.com");
$newsletter->attach($subscriber1);
$newsletter->attach($subscriber2);
$newsletter->attach($subscriber3);
// Set some news and see how the subscribers are notified
$newsletter->setNews("PHP Design Patterns are Awesome!");
$newsletter->setNews("Learn More About PHP Design Patterns Here!");
// Detach one subscriber and set some more news and see how only the remaining subscribers are notified
$newsletter->detach($subscriber2);
$newsletter->setNews("Don't Miss This Amazing Offer on PHP Design Patterns!");