PHP-Entwicklungsmodus Factory-Modus-PHP-Tutorial-php.cn

// 开发模式之工程模式
// 工厂模式：
// 由工厂类根据参数来决定创建出哪一种产品类的实例；
// 工厂类是指包含了一个专门用来创建其他对象的方法的类。所谓按需分配，传入参数进行选择，返回具体的类。
// 工厂模式的最主要作用就是对象创建的封装、简化创建对象操作。 
// 简单的说，就是调用工厂类的一个方法（传入参数）来得到需要的类；


//示例1 最基本的工厂模式

class Myname{
	public function OutPutMyName(){
		return &#39;name is rongyouyuan!~&#39;;
	}
}
class NameFactory{
	public static function Namefunc(){
		return new Myname();
	}
}
$obj=NameFactory::Namefunc();
echo $obj->OutPutMyName();
?>

Nach dem Login kopieren

Das Obige ist das einfachste Fabrikmuster, um einen einfachen Rechner zu implementieren

<?php
//定义一个抽象类
abstract class operation
{
    protected $_numA = 0;
    protected $_numB = 0;
    protected $_result = 0;
    public function __construct($a, $b)
    {
        $this->_numA = $a;
        $this->_numB = $b;
    }
    //抽象方法所有子类必须实现该方法
    protected abstract function getResult();
}
//加法运算
class operationAdd extends operation
{
    public function getResult()
    {
        $this->_result = $this->_numA + $this->_numB;
        return $this->_result;
    }
}
//减法运算
class operationSub extends operation
{
    public function getResult()
    {
        $this->_result = $this->_numA - $this->_numB;
        return $this->_result;
    }
}
//乘法运算
class operationMul extends operation
{
    public function getResult()
    {
        $this->_result = $this->_numA * $this->_numB;
        return $this->_result;
    }
}
//除法运算
class operationDiv extends operation
{
    public function getResult()
    {
        $this->_result = $this->_numA / $this->_numB;
        return $this->_result;
    }
}
//定义工厂类
class operationFactory
{
    //创建保存示例的静态成员变量
    private static $obj;
    //创建实例的静态方法
    public static function CreateOperation($type, $a, $b)
    {
        switch ($type) {
        case &#39;+&#39;:
            self::$obj = new operationAdd($a, $b);
            break;
        case &#39;-&#39;:
            self::$obj = new operationSub($a, $b);
            break;
        case &#39;*&#39;:
            self::$obj = new operationMul($a, $b);
            break;
        case &#39;/&#39;:
            self::$obj = new operationDiv($a, $b);
            break;
        }
        //最后返回这个实例
        return self::$obj;
    }
}
//最后我们使用工厂模式
$obj = operationFactory::CreateOperation(&#39;+&#39;, 100, 20);
echo $obj->getResult();

Nach dem Login kopieren

Schließlich wird die abstrakte Fabrik

definiert: erstellen Eine Reihe verwandter Objekte. Oder stellen Sie eine Schnittstelle für voneinander abhängige Objekte bereit, ohne deren konkrete Klassen anzugeben.

Typ: Klassenmuster erstellen

Klassendiagramm:

PHP-Entwicklungsmodus Factory-Modus

Der Unterschied zwischen abstraktem Fabrikmuster und Fabrikmethodenmuster

Das abstrakte Factory-Muster ist eine aktualisierte Version des Factory-Methodenmusters, das zum Erstellen einer Reihe verwandter oder voneinander abhängiger Objekte verwendet wird. Der Unterschied zum Factory-Methodenmuster besteht darin, dass das Factory-Methodenmuster auf eine hierarchische Produktstruktur abzielt, während das abstrakte Factory-Muster auf mehrere hierarchische Produktstrukturen abzielt. In der Programmierung wird eine Produktstruktur normalerweise durch eine Schnittstelle oder eine abstrakte Klasse dargestellt. Das heißt, alle vom Factory-Methodenmuster bereitgestellten Produkte werden von derselben Schnittstelle oder abstrakten Klasse abgeleitet, während die vom abstrakten Factory-Muster bereitgestellten Produkte abgeleitet werden von verschiedenen Schnittstellen oder abstrakten Klassen.

Im abstrakten Fabrikmuster gibt es ein Konzept der Produktfamilie: Die sogenannte Produktfamilie bezieht sich auf eine Familie funktional verwandter Produkte, die sich in unterschiedlichen Produkthierarchiestrukturen befinden. Die durch das abstrakte Fabrikmuster bereitgestellten Produktreihen bilden eine Produktfamilie, während die durch die Fabrikmethode bereitgestellten Produktreihen als hierarchische Struktur bezeichnet werden. Um die Unterschiede zwischen ihnen zu veranschaulichen, verwenden wir immer noch das Beispiel der Automobilproduktion.

PHP-Entwicklungsmodus Factory-Modus

Im obigen Klassendiagramm werden Schrägheckmodelle und Limousinen als zwei verschiedene hierarchische Strukturen bezeichnet, während Autos mit 2,0 Hubraum und Autos mit 2,4 Hubraum als zwei verschiedene Produktfamilien bezeichnet werden. Genauer gesagt gehören Schräghecklimousinen mit 2,0-Hubraum und Schräghecklimousinen mit 2,4 Hubraum zur gleichen Strukturebene, Limousinen mit 2,0-Hubraum und Limousinen mit 2,4-Hubraum gehören zu einer anderen Strukturebene und Schräghecklimousinen mit 2,0-Hubraum und Limousinen mit 2,0-Hubraum gehören zu einer anderen Strukturebene Struktur; Die Limousine gehört zur gleichen Produktfamilie, und das 2,4-Hubraum-Fließheck und die 2,4-Hubraum-Limousine gehören zu einer anderen Produktfamilie.

Sobald Sie die Konzepte der hierarchischen Struktur und der Produktfamilie verstanden haben, werden Sie den Unterschied zwischen Fabrikmethodenmuster und abstraktem Fabrikmuster verstehen. Wenn die Produkte der Fabrik alle zur gleichen hierarchischen Struktur gehören, gehören sie zur Fabrikmethodenmuster; wenn die Produkte der Fabrik aus mehreren hierarchischen Strukturen bestehen, gehört es zum abstrakten Fabrikmuster. Wenn in diesem Beispiel ein Werksmodell Schräghecklimousinen mit 2,0 Hubraum und Schräghecklimousinen mit 2,4 Hubraum bereitstellt, dann gehört es zum Werksmodell. Wenn ein Werksmodell zwei Produkte bereitstellt: Schräghecklimousinen mit 2,4 Hubraum und Limousinen mit 2,4 Hubraum, dann dieses Werksmuster ist das abstrakte Fabrikmuster, da die von ihm bereitgestellten Produkte zu zwei verschiedenen hierarchischen Strukturen gehören. Wenn eine Fabrik Produkte für alle vier Modelle bereitstellt, gehört sie natürlich auch zum abstrakten Fabrikmodell, da die Produkte zu zwei hierarchischen Strukturen gehören.

Vorteile des abstrakten Fabrikmusters

Zusätzlich zu den Vorteilen des Fabrikmethodenmusters besteht der Hauptvorteil des abstrakten Fabrikmusters darin, dass es dies kann Kontrollprodukte innerhalb der Klasse. Die sogenannten Produktfamilien weisen im Allgemeinen mehr oder weniger bestimmte Korrelationen auf. Das abstrakte Fabrikmuster kann die Korrelationen von Produktfamilien innerhalb der Klasse definieren und beschreiben, ohne dass eine neue Klasse für die Verwaltung eingeführt werden muss.

Nachteile des abstrakten Fabrikmusters

Die Erweiterung der Produktfamilie wird fast eine sehr mühsame Angelegenheit sein all Alle Factory-Klassen müssen geändert werden. Daher ist es bei Verwendung des abstrakten Fabrikmusters sehr wichtig, die Produkthierarchie zu unterteilen.

Anwendbare Szenarien

Wenn es sich bei dem zu erstellenden Objekt um eine Reihe miteinander verbundener oder voneinander abhängiger Produktfamilien handelt, können Sie das abstrakte Fabrikmuster verwenden. Um es klarer auszudrücken: Wenn in einem Vererbungssystem mehrere hierarchische Strukturen vorhanden sind (dh mehrere abstrakte Klassen vorhanden sind) und bestimmte Assoziationen oder Einschränkungen zwischen den Implementierungsklassen bestehen, die zu jeder hierarchischen Struktur gehören, können Sie Folgendes verwenden: abstraktes Fabrikmuster. Wenn zwischen den Implementierungsklassen in jeder hierarchischen Struktur keine Beziehungen oder Einschränkungen bestehen, ist es sinnvoller, mehrere unabhängige Fabriken zum Erstellen von Produkten zu verwenden.

Zusammenfassung

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

<?php
 /** 
 * 抽象工厂模式 
 * ------------- 
 * @author      zhaoxuejie <zxj198468@gmail.com> 
 * @package     design pattern  
 * @version     v1.0 2011-12-14 
 */ 
 
//---------------------------------------------------------------------------
// 抽象工厂(AbstractFactory)角色：它声明一个创建抽象产品对象的接口。
// 通常以接口或抽象类实现，所有的具体工厂类必须实现这个接口或继承这个类。
//---------------------------------------------------------------------------
// 具体工厂(ConcreteFactory)角色：实现创建产品对象的操作。
// 客户端直接调用这个角色创建产品的实例。这个角色包含有选择合适的产品对象的逻辑。通常使用具体类实现。
//---------------------------------------------------------------------------
// 抽象产品(Abstract Product)角色：声明一类产品的接口。它是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
//---------------------------------------------------------------------------
// 具体产品(Concrete Product)角色：实现抽象产品角色所定义的接口，定义一个将被相应的具体工厂创建的产品对象。
// 其内部包含了应用程序的业务逻辑。
//---------------------------------------------------------------------------

///抽象工厂
interface AnimalFactory{
	public function createCat();
	public function createDog();
}

//黑色动物具体工厂
class BlackAnimalFactory implements AnimalFactory{
	function createCat(){
		return new BlackCat();
	}
	function createDog(){
		return new BlackDog();
	}

}
//白色动物具体工厂
class WhiteAnimalFactory implements AnimalFactory{
	function createCat(){
		return new WhiteCat();
	}
	function createDog(){
		return new WhiteDog();
	}
}

//抽象产品
interface Cat{
	function Voice();
}
interface Dog{
	function Voice();
}


//具体产品 
class BlackCat implements Cat {  
      
    function Voice(){  
        echo &#39;黑猫喵喵……&#39;;  
    }  
}  
  
class WhiteCat implements Cat {  
      
    function Voice(){  
        echo &#39;白猫喵喵……&#39;;  
    }  
}  
  
class BlackDog implements Dog {  
      
    function Voice(){  
        echo &#39;黑狗汪汪……&#39;;        
    }  
}  
  
class WhiteDog implements Dog {  
      
    function Voice(){  
        echo &#39;白狗汪汪……&#39;;        
    }  
}  


//客户端


class CLient{
	public static function main(){
		self::run(new BlackAnimalFactory());
		self::run(new WhiteAnimalFactory());
	}
	public static function run(AnimalFactory $AnimalFactory){
	
		$cat=$AnimalFactory->createCat();
		$cat->Voice();
		$dog=$AnimalFactory->createDog();
		$dog->Voice();
	}
}
CLient::main();

Nach dem Login kopieren

更多php 开发模式之工厂模式相关文章请关注PHP中文网！