Modèle de conception couplé en PHP

Cet article présente principalement le modèle de conception de couplage pour l'implémentation de PHP, qui a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Un logiciel qui a de nombreuses classes. Il est nécessaire de s'appeler une fois qu'une classe a une relation étroitement couplée avec une autre classe, la réutilisabilité du logiciel sera considérablement réduite. La réutilisabilité d’un logiciel dépend donc de son degré de couplage.

Degré de couplage : le degré d'association et de dépendance entre les modules du programme.

Proposé lors du processus de conception : lors de la conception de l'architecture de ce logiciel, il a été découvert que la partie opération logique (classe SimpleRouter) et la partie sortie (classe SimpleRouterFrame) de ce logiciel ne peuvent pas être bien combinées. Autrement dit : nous devons transmettre la référence à l'interface du programme (référence à SimpleRouterFrame) couche par couche à la partie centrale du programme pour fournir la fonction de sortie.

Au cours du processus de développement, il a été souligné que lorsque nous apportons quelques modifications à l'interface de sortie (classe SimpleRouterFrame), notamment après la modification des noms de certaines méthodes, le code de la partie centrale correspondante du programme (Classe SimpleRouter) doit également être modifiée pour s'adapter à cette nouvelle interface de sortie.

Cause du problème : Le couplage entre les classes est trop serré, de sorte qu'à chaque fois qu'une classe doit être modifiée, sa classe associée correspondante doit modifier le code pour s'adapter à la classe modifiée. Par exemple : une certaine classe A doit appeler directement la méthode publique d'une autre classe B. Une fois que B ne supporte plus cette méthode, ou réécrit le nom de la méthode, A devra réécrire le code pour s'adapter. Autre situation : une certaine classe A doit utiliser la classe B avec une méthode spécifique, mais la forme de B n'est pas déterminée. Une fois la structure interne de B modifiée, A devra peut-être réécrire le code.

Pour éviter cette situation, il est nécessaire de réduire le couplage entre A et B. Quelle que soit la forme, tant que B peut encore réaliser les fonctions requises par A, A n'a pas besoin de réécrire le code. Solution : Soit B implémente une certaine interface I et définit I.Method(); En même temps, A peut appeler directement la méthode de I lors de l'appel de la méthode de B, dans le passé, B serait transmis à A en tant que paramètre, puis A ; appellerait la méthode de B. L'endroit

1    {      
2        A.AMethod(B b ) {      
3            b.BMethod();      
4            /*….*/      
5        }      
6    }

est modifié en :

1    {      
2        A.AMethod(I i ) {      
3            i.Method();      
4        }      
5    }

Ici, B n'a qu'à implémenter la méthode I.Method(), cachant complètement la méthode. détails de mise en œuvre. Selon cette méthode, un couplage lâche entre les classes est obtenu et la réutilisabilité des classes est grandement améliorée. En repensant aux modèles de conception que nous avons appris auparavant, nous pouvons constater qu'ils sont similaires au modèle Observer.

下面是一个完整的例子：

001    <?php    
002    interface Calculation {    
003        function compute($a, $b);    
004    }    
005         
006    class Addition implements Calculation {    
007        function compute($a, $b)    
008        {    
009            return "加法运算结果为:".($a+$b);    
010        }    
011    }    
012         
013    class Subtraction implements Calculation {    
014        function compute($a, $b)    
015        {    
016            return "减法运算结果为:".($a-$b);    
017        }    
018    }    
019         
020    class Multiplication implements Calculation {    
021        function compute($a, $b)    
022        {    
023            return "乘法运算结果为:".($a*$b);    
024        }    
025    }    
026         
027    class pision implements Calculation{    
028        function compute($a, $b)    
029        {    
030            return "除法运算结果为:".($a/$b);    
031        }    
032    }    
033         
034    class Modf implements Calculation {    
035        function compute($a, $b)    
036        {    
037            return "取模运算结果为:".($a % $b);    
038        }    
039    }    
040         
041    class Coupling implements Calculation {    
042        //这里直接：public $varl = new LazyDog(); 会出错。    
043        public $varl = null;    
044             
045        function __construct()    
046        {    
047            $this->varl = new LazyDog();    
048        }    
049             
050        function compute($a, $b)    
051        {    
052            return $this->varl->say();    
053        }    
054    }    
055         
056    /*也可以用继承的方式实现哟:    
057    class Coupling extends LazyDog implements Calculation {    
058        function compute($a, $b)    
059        {    
060            return parent::say();    
061        }    
062    }    
063    */    
064         
065    class LazyDog {    
066        function say()    
067        {    
068            return "我什么运算都不做...只是为了实现&#39;耦合设计模式&#39;...我是出来打酱油的......";    
069        }    
070    }    
071         
072    class Test {    
073        private $one;    
074        private $two;    
075        public function __construct($x,$y)    
076        {    
077            $this->one=$x;    
078            $this->two=$y;    
079            echo "Class Test 初始化：属性\$one=".$this->one."，属性\$two=".$this->two."<h />";    
080       }    
081       function display(Calculation $a){    
082            return "用PHP接口技术实现的运算：".$a->compute($this->one,$this->two)."<hr/>";    
083       }    
084    }    
085         
086    $t = new Test(96,12);    
087    $t1 = new Addition();    
088    $t2 = new Subtraction();    
089    $t3 = new Multiplication();    
090    $t4 = new pision();    
091    $t5 = new Modf();    
092         
093    $dog = new Coupling();    
094         
095    echo $t->display($t1);    
096    echo $t->display($t2);    
097    echo $t->display($t3);    
098    echo $t->display($t4);    
099    echo $t->display($t5);    
100         
101    echo $t->display($dog);    
102         
103    ?>

程序运行结果：

1    Class Test 初始化：属性$one=96，属性$two=12    
2    用PHP接口技术实现的运算：加法运算结果为:108    
3    用PHP接口技术实现的运算：减法运算结果为:84    
4    用PHP接口技术实现的运算：乘法运算结果为:1152    
5    用PHP接口技术实现的运算：除法运算结果为:8    
6    用PHP接口技术实现的运算：取模运算结果为:0    
7    用PHP接口技术实现的运算：我什么运算都不做...只是为了实现'耦合设计模式'...我是出来打酱油的......

相关推荐：

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!