PHP Design Pattern - Abstract Factory_PHP Tutorial

PHP Design Pattern - Abstract Factory

Earlier we introduced the simple factory and factory method design patterns. Today we learn the last factory - abstract factory.

Case: Treating a girl to a meal is indispensable. When going to McDonald's, just say "two B sets" to the waiter. McDonald's is the AbstractFactory of Package B. Package B contains burgers, chicken wings and drinks. McDonald's or KFC will have the burger Factory, chicken wings factory and beverage factory produce materials corresponding to Package B according to the specifications of Package B.

Abstract Factory Pattern: Provides an interface for creating a series of related or interdependent objects without specifying their concrete classes. Client classes and factory classes are separated. Whenever a consumer needs a certain set of products, he or she only needs to request it from the abstract factory. The abstract factory will then produce products that meet the product set specifications to the specific factory.

UML class diagram implementation:

UML class diagram code implementation:

<!--?php
/**
 * Created by PhpStorm.
 * User: LYL
 * Date: 2015/4/19
 * Time: 17:39
 */

//-----------------------产品------------------------

/**抽象产品角色             充饥食物
 * Interface IAllayFood
 */
interface IAllayFood
{
    function Allay();
}

/**抽象产品角色            解渴食物
 * Interface IDrinkFood
 */
interface IDrinkFood
{
    function Drink();
}

/**具体产品角色           虾仁汉堡
 * Class XiaRenHamb
 */
class XiaRenHamb implements IAllayFood
{
    function Allay()
    {
        echo 虾仁汉堡充饥了。。。。。。。<br/-->;
    }
}

/**具体产品角色            鸡肉汉堡
 * Class ChickenHamb
 */
class ChickenHamb implements IAllayFood
{
    function Allay()
    {
        echo 鸡肉汉堡充饥了。。。。。。。
;
    }
}

/**具体产品角色             可口可乐
 * Class KekouKele
 */
class KekouKele implements IDrinkFood
{

    function Drink()
    {
        echo 可口可乐解渴了。。。。。。。。。
;
    }
}

/**具体产品角色             百事可乐
 * Class BaishiKele
 */
class BaishiKele implements IDrinkFood
{

    function Drink()
    {
        echo 百事可乐解渴了。。。。。。。。
;
    }
}

//-------------------抽象工厂---------------------

/**顶层超级抽象工厂接口
 * Interface IFactory
 */
interface IFactory
{
    //得到充饥食物
    function GetAllayFood();
    //得到解渴食物
    function GetDrinkFood();
}

/**工厂A              A套餐:虾仁汉堡+百事可乐
 * Class IAFactory
 */
class AFactory implements IFactory
{

    function GetAllayFood()
    {
        return new XiaRenHamb();
    }

    function GetDrinkFood()
    {
        return new BaishiKele();
    }
}

/**工厂B                B套餐：鸡肉汉堡+可口可乐
 * Class IBFactory
 */
class BFactory implements IFactory
{

    function GetAllayFood()
    {
        return new ChickenHamb();
    }

    function GetDrinkFood()
    {
        return new KekouKele();
    }
}

Client test code

header(Content-Type:text/html;charset=utf-8);
//------------------------抽象工厂测试代码------------------
require_once ./AbstractFactory/AbstractFactory.php;

//------------------点套餐-------------
$factoryA=new AFactory();
$factoryB=new BFactory();

//------------------麦当劳制作套餐食物------------
//A套餐
$allayA=$factoryA->GetAllayFood();
$drinkA=$factoryA->GetDrinkFood();

//B套餐
$allayB=$factoryB->GetAllayFood();
$drinkB=$factoryB->GetDrinkFood();

//-------------------享受套餐---------------
echo 享受A套餐：
;
$allayA->Allay();
$drinkA->Drink();

echo 享受B套餐:
;
$allayB->Allay();
$drinkB->Drink();

When each abstract product has more than one concrete subclass, how does the factory role know which subclass to instantiate? For example, each abstract product role has two concrete products. The abstract factory pattern provides two specific factory roles, corresponding to these two specific product roles. Each specific factory role is only responsible for the instantiation of a certain product role. Each concrete factory class is only responsible for creating instances of a specific subclass of the abstract product.

Applicable scenarios:

1. Multi-style series of scenes (packages) in game development, such as roads (interfaces), houses, pipes, etc.

2. The system needs to run on three different platforms, such as Windows, Linux, and Android. How will you design it? The abstract factory pattern is used to shield the impact of the operating system on the application. The software functions, application logic, and UI on the three different operating systems should be very similar. The only difference is that different factory methods are called and different product classes handle the information that interacts with the operating system.

3. When the objects that need to be created are a series of interrelated or interdependent product families, the abstract factory pattern can be used.

Summary of the three factory models:

1. The three types are very similar in form and characteristics, and the ultimate goal is decoupling. Encapsulate the object creation process so that the client can get the object directly without having to worry about how to create the object.

2. Comparison

Factory method pattern: used to create complex objects. (A la carte food)

Abstract Factory Pattern: used to create a set of related or interdependent complex objects. (Buy a set meal)

Factory method creation generally has only one method to create a product. Abstract factories generally have multiple methods to create a series of products.

We don’t have to worry about whether the pattern is the factory method pattern or the abstract factory pattern, because the evolution between them is often confusing. The factory method pattern is obviously used. When new requirements come, it is slightly modified and a new method is added. Since the products in the class constitute product families in different hierarchical structures, it becomes the abstract factory pattern, and for abstraction Factory pattern, when one method is reduced so that the provided products no longer constitute a product family, it evolves into the factory method pattern.

http://www.bkjia.com/PHPjc/987357.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/987357.htmlTechArticlePHP Design Pattern - Abstract Factory Earlier we introduced the simple factory and factory method design patterns, today we learn the last one Factory Abstract Factory. Case: When chasing a girl, you must treat her to dinner...