PHP设计模式-抽象工厂模式

最新推荐文章于 2024-12-16 13:00:00 发布

原创最新推荐文章于 2024-12-16 13:00:00 发布 · 377 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#php #抽象工厂模式 #开发语言

PHP设计模式专栏收录该内容

10 篇文章

订阅专栏

本文介绍了抽象工厂模式的概念，通过PHP代码展示了如何创建一个超级工厂来管理猫和狗的行为工厂，实现了创建不同动物行为的实例。代码中定义了接口和实现类，如RunInterface和EatInterface，以及对应的CatFactory和DogFactory，分别用于创建猫和狗的奔跑和吃食行为。两种方法分别通过单一职责的静态方法和多方法工厂进行产品实例的创建。

一、概述

抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式。

二、核心

通过一个超级工厂管理所有的子工厂，把工厂模式的结构分离出来成为能独立运行的个体

三、架构图

在这里插入图片描述

四、代码示例

<?php

/*
 * 抽象工厂模式（Factory Method）
 */

interface RunInterface
{
    public function exec();
}

class CatRun implements RunInterface
{
    public function exec()
    {
        return 'Cat Run';
    }

}

class DogRun implements RunInterface
{
    public function exec()
    {
        return 'Dog Run';
    }
}


interface EatInterfact
{
    public function exec();
}

class CatEat implements EatInterfact
{
    public function exec()
    {
        return 'Cat Eat';
    }
}

class DogEat implements EatInterfact
{
    public function exec()
    {
        return 'Dog Eat';
    }
}


interface FactoryInterface
{
    public static function createAnimal($type);
}

class CatFactory implements FactoryInterface
{
    //方法一
    public static function createAnimal($type)
    {
        switch ($type){
            case "Run":
                return new CatRun();
            case "Eat":
                return new CatEat();
            default:
                return false;
        }
    }

    //方法二
    public static function createCatRun()
    {
        return new CatRun();
    }
    public static function createCatEat()
    {
        return new CatEat();
    }
}

class DogFactory implements FactoryInterface
{
    //方法一
    public static function createAnimal($type)
    {
        switch ($type){
            case "Run":
                return new DogRun();
            case "Eat":
                return new DogEat();
            default:
                return false;
        }
    }
    //方法二
    public static function createDogRun()
    {
        return new DogRun();
    }
    public static function createDogEat()
    {
        return new DogEat();
    }
}
//方法一
$cat['run'] = CatFactory::createAnimal('Run')->exec();
$cat['eat'] = CatFactory::createAnimal('Eat')->exec();
//方法二
$cat['2run'] = CatFactory::createCatRun()->exec();
$cat['2eat'] = CatFactory::createCatEat()->exec();


//方法一
$dog['run'] = DogFactory::createAnimal('Run')->exec();
$dog['eat'] = DogFactory::createAnimal('Eat')->exec();
//方法二
$dog['2run'] = DogFactory::createDogRun()->exec();
$dog['2eat'] = DogFactory::createDogEat()->exec();

五、总结

一个抽象产品类派生多个具体产品类（EatInterface=>[CatEatClass,DogEatClass], RunInterface=>[CatRunClass, DogRunclass]）
一个抽象工厂类可以派生出多个具体工厂类（FactoryInterface=>[CatFactory, DogFactory]）
每个具体的工厂类创建多个具体的产品实例（{CatFactory=>[CatEatClass, CatRunClass], DogFactory=>[DogRunClass, DogEatClass]}）