Objektorientierte PHP-Entwicklung – Factory-Muster

Laienhaft ausgedrückt bezieht sich das Factory-Muster auf die Erstellung einer Klassenfamilie für einige Klassen mit derselben Struktur und die Bereitstellung einer eindeutigen Einstiegsklasse für diese Familie. Bitte beachten Sie die Beschreibung „gleiche Struktur“. Sie bezieht sich darauf, dass ein bestimmter Objekttyp einige Merkmale aufweist, die es uns ermöglichen, ihn von anderen Objekten zu unterscheiden. Beispielsweise gibt es eine Assoziationsfrage und wir assoziieren dasselbe durch zwei Worte. „Vier Räder, brennendes Benzin.“ Ich denke, man kann sofort an Autos, Transporter, Taxis und andere Autos denken, aber nicht an Motorräder. Die „vier Räder“ und „brennendes Benzin“ sind hier die gleichen Merkmale von Autos, Transportern und Taxis. Wir verwenden sie, um Autos, Transporter und Taxis in die Gruppe „Auto“ einzuteilen.

Zurück zu PHP, hier veranschaulichen wir das Factory-Muster anhand von Beispielen.

Jetzt gibt es eine Autofabrik, die Autos und Busse herstellt. Autos und Busse bestehen aus Motoren, Karosserien und Rädern.

Analyse:

1. Es gibt gemeinsame Standards für die Produktion verschiedener Autos und es müssen Motoren, Karosserien und Räder hergestellt werden. Daher können wir eine Schnittstellenklasse für die Produktion von Autos entwickeln . Alle Fahrzeugtypen müssen den Standards dieser Schnittstellenklasse entsprechen.

2. Die Außenwelt muss Zugang von der Fabrik zur Produktion von Autos und Bussen ermöglichen.

//生产汽车的标准  
    interface carNorms{  
        function engine();//引擎  
        function body();//车身  
        function whell();//轮子  
    }  
      
    //生产小汽车  
    class car implements carNorms{  
          
        public function engine(){  
            return '汽车引擎';  
        }  
          
        public function body(){  
            return '汽车车身';  
        }  
          
        public function whell(){  
            return '汽车轮子';  
        }  
          
    }  
      
    //生产巴士车  
    class bus implements carNorms{  
          
        public function engine(){  
            return '巴士引擎';  
        }  
          
        public function body(){  
            return '巴士车身';  
        }  
          
        public function whell(){  
            return '巴士轮子';  
        }  
          
    }  
      
    //汽车工厂  
    class carFactory{  
          
        static public function carInstance($type){  
            $instance='';  
            switch($type){  
                case 'car':  
                    $instance=new car();  
                    break;  
                case 'bus':  
                    $instance=new bus();  
                    break;  
                default:  
                    throw new Exception('本工厂无法生产这种类型的车');  
            }  
            if(!$instance instanceof carNorms){  
                throw new Exception('这种车不符合生产标准');  
            }  
            return $instance;  
        }  
          
    }  
      
    $createCar=carFactory::carInstance('car');  
    $car['engine']=$createCar->engine();  
    $car['body']=$createCar->body();  
    $car['whell']=$createCar->whell();  
      
    print_r($car);

Dies ist eine Standard-Fabrikklasse. Jetzt sind neue Anforderungen gekommen und die Fabrik muss auch LKWs produzieren.

Analyse: Da die Produktions-Lkw auch den Produktionsstandards der Fabrik entsprechen, können wir die Lkw-Klasse direkt hinzufügen und den entsprechenden Eingang zur Fabrikklasse hinzufügen.

class truck implements carNorms{  
          
        public function engine(){  
            return '卡车引擎';  
        }  
          
        public function body(){  
            return '卡车车身';  
        }  
          
        public function whell(){  
            return '卡车轮子';  
        }  
          
    }

//汽车工厂    
    class carFactory{    
            
        static public function carInstance($type){    
            $instance='';    
            switch($type){    
                case 'car':    
                    $instance=new car();    
                    break;    
                case 'bus':    
                    $instance=new bus();    
                    break;    
                case 'truck':    
                    $instance=new truck();    
                    break;    
                default:    
                    throw new Exception('本工厂无法生产这种类型的车');    
            }    
            if(!$instance instanceof carNorms){    
                throw new Exception('这种车不符合生产标准');    
            }    
            return $instance;    
        }    
            
    }

Es ist einfach zu vervollständigen, aber gehen wir hier davon aus, dass, wenn sich die Produktionsstandards ändern, Qualitätsprüfungen zum Produktionsprozess hinzugefügt werden müssen Schnittstelle Qualitätsprüfmethoden.

//生产汽车的标准  
    interface carNorms{  
        function engine();//引擎  
        function body();//车身  
        function whell();//轮子  
        function check();//质量测试  
    }

Das Problem besteht darin, dass alle in der Fabrik hergestellten Autos Qualitätskontrollmethoden umfassen müssen. In dieser Fabrik werden nur drei Arten von Autos hergestellt, was nicht sehr problematisch zu sein scheint. Aber denken wir noch einmal darüber nach: Wenn eine Fabrik Tausende von Produkten hat und ein Standard hinzugefügt wird, wird dieser Standard jedem Produkt hinzugefügt. Wie viel Kosten entstehen dann! Dies ist der Nachteil der Factory-Methode. Seien Sie vorsichtig, wenn Sie das Factory-Muster verwenden!

Das Obige ist der Inhalt der objektorientierten PHP-Entwicklung – Factory-Modus. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).