Zusammenfassung von 16 Entwurfsmustern in PHP

Hinweis: Dieses Tutorial ist vollständig ein Auszug aus dem Labor-Tutorial [Detaillierte Erläuterung von 16 PHP-Entwurfsmustern]: Es führt hauptsächlich in die grundlegenden Konzepte und technischen Punkte von 16 häufig verwendeten Entwurfsmustern ein und verwendet zur Unterstützung UML-Klassendiagramme Verstehen Sie die Beziehung zwischen den einzelnen Klassen und ein Codebeispiel mit PHP für jedes Entwurfsmuster, sodass Sie anhand des Beispiels problemlos mit dem Entwurfsmuster beginnen können.

1. Fabrikmuster

Fabrikmuster können in drei Arten von Mustern unterteilt werden: einfache Fabrikmuster, Fabrikmethodenmuster, abstrakte Fabrikmuster; Das Simple Factory-Muster

wird auch als Static Factory Method-Muster bezeichnet und gehört zum Klassenerstellungsmuster. Im einfachen Factory-Muster können Instanzen verschiedener Klassen gemäß unterschiedlichen Parametern zurückgegeben werden. Das einfache Factory-Muster definiert speziell eine Klasse, die für die Erstellung von Instanzen anderer Klassen verantwortlich ist. Die erstellten Instanzen haben normalerweise eine gemeinsame übergeordnete Klasse.

Rolle:

Fabrikklasse: Verantwortlich für die Erstellung von Instanzen bestimmter Produkte
Produktklasse : Abstrakte Produktklasse, definiert die öffentliche Schnittstelle der Produktunterklasse
ConcreteProduct-Klasse: Konkrete Produktklasse, implementiert die Schnittstellenfunktion der übergeordneten Produktklasse und kann auch benutzerdefinierte Funktionen hinzufügen

UML-Klassendiagramm:

Beispielcode:

Der größte Vorteil des einfachen Factory-Musters besteht darin, dass die Erstellung von Objekten und die Verwendung von Objekten getrennt werden und die Erstellung von Objekten einer speziellen Factory-Klasse überlassen wird. Der größte Nachteil besteht jedoch darin, dass die Factory-Klasse nicht flexibel genug ist Das Hinzufügen neuer spezifischer Produkte erfordert eine Änderung der Fabrikklasse. Bei der Beurteilung des Logikcodes ist der Fabrikmethodencode sehr kompliziert.

<?php  
//简单工厂模式
class Cat
{
  function __construct()
  {
      echo "I am Cat class <br>";
  }
}
class Dog
{
  function __construct()
  {
      echo "I am Dog class <br>";
  }
}
class Factory
{
  public static function CreateAnimal($name){
      if ($name == 'cat') {
          return new Cat();
      } elseif ($name == 'dog') {
          return new Dog();
      }
  }
}

$cat = Factory::CreateAnimal('cat');
$dog = Factory::CreateAnimal('dog');

2. Factory-Methodenmuster

In diesem Muster wird durch die Definition einer abstrakten Kern-Factory-Klasse und der Definition einer Schnittstelle zum Erstellen von Produktobjekten die Arbeit zum Erstellen spezifischer Produktinstanzen auf ihre Factory-Unterklassen verzögert Geh und mach Schluss. Dies hat den Vorteil, dass sich die Kernklasse nur auf die Schnittstellendefinition der Factory-Klasse konzentriert und die Erstellung bestimmter Produktinstanzen der jeweiligen Factory-Unterklasse überlassen bleibt. Wenn das System ein neues Produkt hinzufügen muss, muss der vorhandene Systemcode nicht geändert werden. Sie müssen lediglich eine bestimmte Produktklasse und die entsprechende Factory-Unterklasse hinzufügen. Dadurch wird das System skalierbarer und entspricht dem Öffnungs- und Schließprinzip der objektorientierten Programmierung;

Rolle:

Produkt: abstrakte Produktklasse
ConcreteProduct : Betonproduktklasse
Factory: abstrakte Fabrikklasse
ConcreteFactory: Betonfabrikklasse

UML-Klassendiagramm:

Beispielcode:

Das Factory-Methodenmuster ist eine weitere Abstraktion und Förderung des einfachen Fabrikmusters. Aufgrund der Verwendung von objektorientiertem Polymorphismus behält das Factory-Methodenmuster die Vorteile des einfachen Factory-Musters bei und überwindet dessen Nachteile. Im Factory-Methodenmuster ist die Kern-Factory-Klasse nicht mehr für die Erstellung aller Produkte verantwortlich, sondern überlässt die spezifische Erstellungsarbeit den Unterklassen. Diese Kernklasse ist nur für die Bereitstellung der Schnittstelle verantwortlich, die eine bestimmte Fabrik implementieren muss, und nicht für die Details, wie die Produktklasse instanziiert wird. Dadurch kann das Fabrikmethodenmuster es dem System ermöglichen, neue Produkte einzuführen, ohne die Fabrik zu ändern Rolle.

<?php  
interface Animal{
  public function run();
  public function say();
}
class Cat implements Animal
{
  public function run(){
      echo "I ran slowly <br>";
  }
  public function say(){
      echo "I am Cat class <br>";
  }
}
class Dog implements Animal
{
  public function run(){
      echo "I'm running fast <br>";
  }
  public function say(){
      echo "I am Dog class <br>";
  }
}
abstract class Factory{
  abstract static function createAnimal();
}
class CatFactory extends Factory
{
  public static function createAnimal()
  {
      return new Cat();
  }
}
class DogFactory extends Factory
{
  public static function createAnimal()
  {
      return new Dog();
  }
}

$cat = CatFactory::createAnimal();
$cat->say();
$cat->run();

$dog = DogFactory::createAnimal();
$dog->say();
$dog->run();

3. Abstraktes Fabrikmuster

Bietet eine Schnittstelle zum Erstellen einer Reihe verwandter oder voneinander abhängiger Objekte, ohne deren spezifische Klassen anzugeben. Das abstrakte Factory-Muster, auch Kit-Muster genannt, ist ein Objekterstellungsmuster.

Dieses Muster ist eine weitere Erweiterung des Factory-Methodenmusters. Im Factory-Methodenmuster ist eine bestimmte Fabrik für die Herstellung eines bestimmten Produkttyps verantwortlich, d verwendet werden.

Um das Verständnis dieses Modells zu erleichtern, werden hier zwei Konzepte vorgestellt:

• Produktebenenstruktur

  : Die Produktebenenstruktur ist die Vererbungsstruktur des Produkts, z. B. Eine abstrakte Klasse ist ein Fernseher, und seine Unterklassen umfassen Haier TV, Hisense TV und TCL TV. Zwischen dem abstrakten Fernseher und der spezifischen Marke des Fernsehers wird eine Produkthierarchiestruktur gebildet die übergeordnete Klasse, und der abstrakte Fernseher ist die übergeordnete Klasse. Bestimmte Fernsehmarken sind ihre Unterkategorien.

• Produktfamilie:

  Im abstrakten Fabrikmuster bezieht sich eine Produktfamilie auf eine Gruppe von Produkten, die von derselben Fabrik hergestellt werden und sich in unterschiedlichen Produkthierarchiestrukturen befinden, z Da Haier-Fernseher und Haier-Kühlschränke von der Haier Electrical Appliance Factory hergestellt werden, sind Haier-Fernseher in der TV-Produktebenenstruktur und Haier-Kühlschränke in der Kühlschrank-Produktebenenstruktur angeordnet.

Rolle:

Abstract Factory: Diese Rolle ist der Kern des Abstract Factory-Musters und hat nichts damit zu tun mit der Geschäftslogik des Anwendungssystems zu tun haben.

• 具体工厂（Factory）：这个角色直接在客户端的调用下创建产品的实例，这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统商业逻辑紧密相关的。

• 抽象产品（AbstractProduct）：担任这个角色的类是抽象工厂模式所创建的对象的父类，或它们共同拥有的接口

• 具体产品（Product）：抽象工厂模式所创建的任何产品对象都是一个具体的产品类的实例。

UML类图：

示例代码：

<?php  

interface TV{
  public function open();
  public function use();
}

class HaierTv implements TV
{
  public function open()
  {
      echo "Open Haier TV <br>";
  }

  public function use()
  {
      echo "I'm watching TV <br>";
  }
}

interface PC{
  public function work();
  public function play();
}

class LenovoPc implements PC
{
  public function work()
  {
      echo "I'm working on a Lenovo computer <br>";
  }
  public function play()
  {
      echo "Lenovo computers can be used to play games <br>";
  }
}

abstract class Factory{
  abstract public static function createPc();
  abstract public static function createTv();
}

class ProductFactory extends Factory
{
  public static function createTV()
  {
      return new HaierTv();
  }
  public static function createPc()
  {
      return new LenovoPc();
  }
}

$newTv = ProductFactory::createTV();
$newTv->open();
$newTv->use();

$newPc = ProductFactory::createPc();
$newPc->work();
$newPc->play();

二、建造者模式

又名：生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。例如，一辆汽车由轮子，发动机以及其他零件组成，对于普通人而言，我们使用的只是一辆完整的车，这时，我们需要加入一个构造者，让他帮我们把这些组件按序组装成为一辆完整的车。

角色：

• Builder：抽象构造者类，为创建一个Product对象的各个部件指定抽象接口。

• ConcreteBuilder：具体构造者类，实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示。提供一个检索产品的接口

• Director：指挥者，构造一个使用Builder接口的对象。

• Product：表示被构造的复杂对象。ConcreateBuilder创建该产品的内部表示并定义它的装配过程。
  包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

UML类图：

示例代码：

<?php  
/**
* chouxiang builer
*/
abstract class Builder
{
  protected $car;
  abstract public function buildPartA();
  abstract public function buildPartB();
  abstract public function buildPartC();
  abstract public function getResult();
}

class CarBuilder extends Builder
{
  function __construct()
  {
      $this->car = new Car();
  }
  public function buildPartA(){
      $this->car->setPartA('发动机');
  }

  public function buildPartB(){
      $this->car->setPartB('轮子');
  }

  public function buildPartC(){
      $this->car->setPartC('其他零件');
  }

  public function getResult(){
      return $this->car;
  }
}

class Car
{
  protected $partA;
  protected $partB;
  protected $partC;

  public function setPartA($str){
      $this->partA = $str;
  }

  public function setPartB($str){
      $this->partB = $str;
  }

  public function setPartC($str){
      $this->partC = $str;
  }

  public function show()
  {
      echo "这辆车由：".$this->partA.','.$this->partB.',和'.$this->partC.'组成';
  }
}

class Director
{
  public $myBuilder;

  public function startBuild()
  {
      $this->myBuilder->buildPartA();
      $this->myBuilder->buildPartB();
      $this->myBuilder->buildPartC();
      return $this->myBuilder->getResult();
  }

  public function setBuilder(Builder $builder)
  {
      $this->myBuilder = $builder;
  }
}

$carBuilder = new CarBuilder();
$director = new Director();
$director->setBuilder($carBuilder);
$newCar = $director->startBuild();
$newCar->show();

三、单例模式

单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。

实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

---维基百科

单例模式的要点有：某个类只能有一个实例；它必须自行创建本身的实例；它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。

角色：

• Singleton：单例类

UML 类图：

示例代码：

<?php  

class Singleton
{
  private static $instance;
  //私有构造方法，禁止使用new创建对象
  private function __construct(){}

  public static function getInstance(){
      if (!isset(self::$instance)) {
          self::$instance = new self;
      }
      return self::$instance;
  }
  //将克隆方法设为私有，禁止克隆对象
  private function __clone(){}

  public function say()
  {
      echo "这是用单例模式创建对象实例 <br>";
  }
  public function operation()
  {
      echo "这里可以添加其他方法和操作 <br>";
  }
}

// $shiyanlou = new Singleton();
$shiyanlou = Singleton::getInstance();
$shiyanlou->say();
$shiyanlou->operation();

$newShiyanlou = Singleton::getInstance();
var_dump($shiyanlou === $newShiyanlou);

上述的五个模式均属于创建型模式，关于结构型模式，点击【16个PHP设计模式详解】即可查看了……

Das obige ist der detaillierte Inhalt vonZusammenfassung von 16 Entwurfsmustern in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!