Partage du didacticiel vidéo PHP du modèle de conception Power Academy

"Tutoriel vidéo PHP Power Academy Design Pattern" présente d'abord le modèle de conception, indique l'utilisation et l'importance du modèle de conception et explique en détail les occasions dans lesquelles le modèle de conception est appliqué. Ensuite, un certain nombre de modèles de conception sont présentés à travers des exemples de code. Enfin, une analyse de cas complète et approfondie illustre comment utiliser des modèles de conception pour planifier de nouvelles applications, comment écrire ces modèles en langage PHP et comment utiliser les modèles de conception présentés dans la vidéo pour modifier et refactoriser les blocs de code existants.

Adresse de lecture du cours : http://www.php.cn/course/424.html

Le style d'enseignement du professeur :

Les cours du professeur sont simples et approfondis, de structure claire, analysés couche par couche, imbriqués, rigoureux dans l'argumentation, rigoureux dans la structure , utilisant le pouvoir logique de la pensée pour attirer l'attention des étudiants et le contrôle rationnel du processus d'enseignement en classe. En écoutant les cours des enseignants, les étudiants non seulement acquièrent des connaissances, mais reçoivent également une formation à la réflexion, et sont également influencés et influencés par l'attitude académique rigoureuse des enseignants.

Le point le plus difficile dans cette vidéo est le modèle de méthode d'usine expliqué en détail :

1 Introduction au modèle

Définir une interface de création d'objets, de sorte que les sous-classes décident quelle classe instancier et que les méthodes d'usine reportent l'instanciation d'une classe à ses sous-classes.

2 Rôles dans le modèle

2.1 Rôle Abstract Factory (Créateur) : C'est le cœur du modèle de méthode d'usine et n'a rien à voir avec l'application. Toute classe de fabrique pour les objets créés dans le modèle doit implémenter cette interface.
2.2 Rôle Concrete Creator (Concrete Creator) : il s'agit d'une classe d'usine concrète qui implémente l'interface d'usine abstraite, contient une logique étroitement liée à l'application et est appelée par l'application pour créer des objets produit. Il existe deux rôles de ce type dans l'image ci-dessus : BulbCreator et TubeCreator.
2.3 Rôle de produit abstrait (Product) : le super type de l'objet créé par le modèle de méthode d'usine, qui est la classe parent commune ou l'interface commune de l'objet produit. Dans l'image ci-dessus, ce personnage est Light.
2.4 Rôle Produit concret : Ce rôle implémente l'interface définie par le rôle produit abstrait. Un produit spécifique est créé dans une usine spécifique et il existe souvent une correspondance individuelle entre eux.

Conception du code source PHP

<?php  
/** 
 * 工厂方法。由于简单工厂违背了开发-封闭原则 
 * 工厂方法。将这个改变放到了客户端 
 * copyright (c) http://blog.csdn.net/CleverCode     
 */  
  
// 运算抽象类    
class Operation  
{  /*{{{*/  
  
    // 数字A    
    protected $_numberA = null;    
  
    // 数字B    
    protected $_numberB = null;    
  
    /**  
     * 设置成员A  
     *  
     * @param double $num 数字  
     * @return void  
     */    
    public function setNumberA($num){    
        $this->_numberA = $num;    
    }    
  
    /**  
     * 获取成员A  
     *  
     * @return double 数字  
     */    
    public function getNumberA(){    
        return $this->_numberA;    
    }    
  
    /**  
     * 设置成员B  
     *  
     * @param double $num 数字  
     * @return void  
     */    
    public function setNumberB($num){    
        $this->_numberB = $num;    
    }    
  
    /**  
     * 获取成员B  
     *  
     * @return double 数字  
     */    
    public function getNumberB(){    
        return $this->_numberA;    
    }    
  
    /**  
     * 获取运算结果  
     *  
     * @return double 数字  
     */    
    public function getResult(){    
        return null;    
    }    
}  /*}}}*/  
  
// 加法类    
class OperationAdd extends Operation  
{  /*{{{*/  
  
    /**  
     * 获取运算结果  
     *  
     * @return double 数字  
     */    
    public function getResult(){    
        return $this->_numberA + $this->_numberB;    
    }    
}  /*}}}*/  
  
// 减法类    
class OperationSub extends Operation  
{  /*{{{*/  
  
    /**  
     * 获取运算结果  
     *  
     * @return double 数字  
     */    
    public function getResult(){    
        return $this->_numberA - $this->_numberB;    
    }    
}  /*}}}*/  
  
//运算工厂  
interface IFactory  
{/*{{{*/  
    public function createOperate();  
}/*}}}*/  
  
//加法工厂  
class AddFactory implements IFactory  
{/*{{{*/  
  
    public function createOperate()  
    {  
        return new  OperationAdd();   
    }  
}/*}}}*/  
  
//减法工厂  
class SubFactory implements IFactory   
{/*{{{*/  
    public function createOperate()  
    {  
        return new OperationSub();   
    }  
}/*}}}*/  
  
class Client   
{/*{{{*/  
    public static function main($argv)  
    {  
       //简单工厂的switch case 放到了客户端了  
       $factory = new AddFactory();  
       $add = $factory->createOperate();  
       // 设置数字A    
       $add->setNumberA(5);    
            
       // 设置数字B    
       $add->setNumberB(2);    
            
       // 运算    
       echo $add->getResult()."\r\n";     
           
    }  
}/*}}}*/  
  
Client::main($argv);  
  
?>

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!