Remarque : ce tutoriel est entièrement extrait du tutoriel de laboratoire [Explication détaillée de 16 modèles de conception PHP] : il présente principalement les concepts de base et les points techniques de 16 modèles de conception couramment utilisés, et utilise des diagrammes de classes UML pour vous aider. comprendre les modèles de conception. La relation entre chaque classe et un exemple de code utilisant PHP pour chaque modèle de conception, vous permettant de démarrer facilement avec le modèle de conception en suivant l'exemple.

1. Modèle d'usine

Le modèle d'usine peut être divisé en trois types de modèles : modèle d'usine simple, modèle de méthode d'usine, modèle d'usine abstrait

1. Le modèle Simple Factory

est également appelé modèle Static Factory Method, qui appartient au modèle de création de classe. Dans le modèle d'usine simple, les instances de différentes classes peuvent être renvoyées en fonction de différents paramètres. Le modèle de fabrique simple définit spécifiquement une classe responsable de la création d'instances d'autres classes. Les instances créées ont généralement une classe parent commune.

Rôle :

Classe d'usine : Responsable de la création d'instances de produits spécifiques
Classe de produits : Classe de produit abstraite, définit l'interface publique de la sous-classe de produit
Classe ConcreteProduct : classe de produit concrète, implémente la fonction d'interface de la classe parent Product et peut également ajouter des fonctions personnalisées

Diagramme de classes UML :

Résumé de 16 modèles de conception en PHP

Exemple de code :

<?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');

Copier après la connexion

Le plus grand avantage du modèle d'usine simple est de séparer la création d'objets et l'utilisation d'objets, et de laisser la création d'objets à une classe d'usine spécialisée. Cependant, son plus grand inconvénient est que la classe d'usine n'est pas assez flexible. L'ajout de nouveaux produits spécifiques nécessite de modifier la classe d'usine. Lors du jugement du code logique et qu'il existe de nombreux produits, le code de la méthode d'usine sera très compliqué.

2. Modèle de méthode d'usine

Dans ce modèle, en définissant une classe d'usine de base abstraite et en définissant une interface pour créer des objets de produit, le travail de création d'instances de produit spécifiques est reporté à ses sous-classes d'usine. Allez finir. L'avantage de ceci est que la classe principale se concentre uniquement sur la définition de l'interface de la classe d'usine et que les instances de produit spécifiques sont laissées à la sous-classe d'usine spécifique pour la création. Lorsque le système doit ajouter un nouveau produit, il n'est pas nécessaire de modifier le code système existant. Il vous suffit d'ajouter une classe de produit spécifique et sa sous-classe d'usine correspondante. Cela rend le système plus évolutif et conforme au principe d'ouverture et de fermeture. de programmation orientée objet ;

Rôle :

Produit : classe de produit abstraite
ConcreteProduct : classe de produits en béton
Usine : classe d'usine abstraite
ConcreteFactory : classe d'usine en béton

Diagramme de classes UML :

Résumé de 16 modèles de conception en PHP

Exemple de code :

<?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();

Copier après la connexion

Le modèle de méthode d'usine est un autre abstraction et promotion du modèle d'usine simple. Grâce à l'utilisation du polymorphisme orienté objet, le modèle de méthode d'usine conserve les avantages du modèle d'usine simple et surmonte ses inconvénients. Dans le modèle de méthode d'usine, la classe d'usine principale n'est plus responsable de la création de tous les produits, mais laisse le travail de création spécifique aux sous-classes. Cette classe principale est uniquement responsable de fournir l'interface qu'une usine spécifique doit implémenter et n'est pas responsable des détails de la façon dont la classe de produit est instanciée. Cela permet au modèle de méthode d'usine de permettre au système d'introduire de nouveaux produits sans modifier l'usine. rôle.

3. Modèle d'usine abstrait

Fournit une interface pour créer une série d'objets liés ou interdépendants sans spécifier leurs classes spécifiques. Abstract Factory Pattern, également connu sous le nom de Kit Pattern, est un modèle de création d'objets.

Ce modèle est une extension supplémentaire du modèle de méthode d'usine. Dans le modèle de méthode d'usine, une usine spécifique est responsable de la production d'un type spécifique de produit, c'est-à-dire une relation un-à-un. Cependant, si une usine spécifique doit produire plusieurs objets de produit, alors le modèle d'usine abstrait est nécessaire. à utiliser.

Afin de faciliter la compréhension de ce modèle, deux concepts sont introduits ici :

Structure au niveau produit : La structure au niveau produit est la structure d'héritage du produit, telle qu'une classe abstraite est un téléviseur, et ses sous-classes incluent Haier TV, Hisense TV et TCL TV. Une structure hiérarchique de produit est formée entre le téléviseur abstrait et la marque spécifique de téléviseur. la classe parent, et la télévision abstraite est la classe parent. Les marques spécifiques de téléviseurs sont ses sous-catégories.
Famille de produits : Dans le modèle abstrait d'usine, une famille de produits fait référence à un groupe de produits fabriqués par la même usine et situés dans différentes structures hiérarchiques de produits, telles que Comme les téléviseurs Haier et les réfrigérateurs Haier sont produits par Haier Electrical Appliance Factory, les téléviseurs Haier sont situés dans la structure au niveau des produits TV, et les réfrigérateurs Haier sont situés dans la structure au niveau des produits réfrigérateur.

Rôle :

Abstract Factory : Ce rôle est au cœur du modèle Abstract Factory et n'a rien à voir avec à voir avec la logique métier du système d'application.
具体工厂（Factory）：这个角色直接在客户端的调用下创建产品的实例，这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统商业逻辑紧密相关的。
抽象产品（AbstractProduct）：担任这个角色的类是抽象工厂模式所创建的对象的父类，或它们共同拥有的接口
具体产品（Product）：抽象工厂模式所创建的任何产品对象都是一个具体的产品类的实例。

UML类图：

Résumé de 16 modèles de conception en PHP

示例代码：

<?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();

Copier après la connexion

二、建造者模式

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

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

角色：

Builder：抽象构造者类，为创建一个Product对象的各个部件指定抽象接口。
ConcreteBuilder：具体构造者类，实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示。提供一个检索产品的接口
Director：指挥者，构造一个使用Builder接口的对象。
Product：表示被构造的复杂对象。ConcreateBuilder创建该产品的内部表示并定义它的装配过程。
包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

UML类图：

Résumé de 16 modèles de conception en PHP

示例代码：

<?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();

Copier après la connexion

三、单例模式

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

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

---维基百科

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

角色：

Singleton：单例类

UML 类图：

Résumé de 16 modèles de conception en PHP

示例代码：

<?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);

Copier après la connexion

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!