PHP object-oriented development-factory pattern

Generally speaking, the factory pattern refers to creating a class family for some classes with the same structure and providing a unique entry class for this family. Please pay attention to the description of "same structure". It refers to that a certain type of object has some characteristics that allow us to distinguish it from other objects. For example, there is an association question and we associate the same thing through two words. "Four wheels, burning gasoline." I think you can immediately think of cars, vans, taxis and other cars, but not motorcycles. The "four wheels" and "burning gasoline" here are the same characteristics of cars, vans, and taxis. We use them to classify cars, vans, and taxis into the "car" group.

Back to PHP, here we will illustrate the factory mode with examples.

Now there is a car factory that produces cars and buses. Cars and buses are composed of engines, bodies and wheels.

Analysis:

1. There are common standards for the production of various cars. Engines, bodies and wheels must be produced. Therefore, we can develop an interface class for the production of cars. All types of cars must Follow the standards in this interface class.

2. The outside world needs to provide access from the factory to the production of cars and buses.

//生产汽车的标准  
    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);

This is a standard factory class. Now new requirements have come and the factory also needs to produce trucks.

Analysis: Since the production trucks also meet the production standards of the factory, we can directly add the truck class and add the corresponding entrance to the factory class.

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;    
        }    
            
    }

It’s done easily, but let’s assume here that if the production standards change, quality testing needs to be added to the production process. To complete this change, we must add quality testing methods to the interface.

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

The trouble is that all cars produced in the factory must incorporate quality inspection methods. In this factory, only three types of cars are produced, which does not seem to be very troublesome. But let's think about it again, if a factory has thousands of products, adding a standard will add this standard to every product, how much cost will be incurred! This is the shortcoming of the factory method. Be careful when using the factory pattern!

The above is the content of PHP object-oriented development - factory mode. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!