工厂模式--php实现

其他 2018-11-08 08:41:05 阅读次数: 0

简单工厂模式
①抽象基类：类中定义抽象一些方法，用以在子类中实现
②继承自抽象基类的子类：实现基类中的抽象方法
③工厂类：用以实例化所有相对应的子类

例一

/**
     * 
     * 定义个抽象的类，让子类去继承实现它
     *
     */
     abstract class Operation{
         //抽象方法不能包含函数体
         abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数
     }



     /**
      * 加法类
      */
     class OperationAdd extends Operation {
         public function getValue($num1,$num2){
             return $num1+$num2;
         }
     }
     /**
      * 减法类
      */
     class OperationSub extends Operation {
         public function getValue($num1,$num2){
             return $num1-$num2;
         }
     }
     /**
      * 乘法类
      */
     class OperationMul extends Operation {
         public function getValue($num1,$num2){
             return $num1*$num2;
         }
     }
     /**
      * 除法类
      */
     class OperationDiv extends Operation {
         public function getValue($num1,$num2){
             try {
                 if ($num2==0){
                     throw new Exception("除数不能为0");
                 }else {
                     return $num1/$num2;
                 }
             }catch (Exception $e){
                 echo "错误信息：".$e->getMessage();
             }
         }
     }

通过采用面向对象的继承特性，我们可以很容易就能对原有程序进行扩展，比如:‘乘方’，‘开方’，‘对数’，‘三角函数’，‘统计’等，以还可以避免加载没有必要的代码。

如果我们现在需要增加一个求余的类，会非常的简单

我们只需要另外写一个类（该类继承虚拟基类）,在类中完成相应的功能（比如：求乘方的运算）,而且大大的降低了耦合度，方便日后的维护及扩展

/**
     * 求余类（remainder）
     *
     */
    class OperationRem extends Operation {
        public function getValue($num1,$num2){
            return $num1%$num12;
        }
    }

现在还有一个问题未解决,就是如何让程序根据用户输入的操作符实例化相应的对象呢？
解决办法：使用一个单独的类来实现实例化的过程，这个类就是工厂

/**
     * 工程类，主要用来创建对象
     * 功能：根据输入的运算符号，工厂就能实例化出合适的对象
     *
     */
    class Factory{
        public static function createObj($operate){
            switch ($operate){
                case '+':
                    return new OperationAdd();
                    break;
                case '-':
                    return new OperationSub();
                    break;
                case '*':
                    return new OperationSub();
                    break;
                case '/':
                    return new OperationDiv();
                    break;
            }
        }
    }
    $test=Factory::createObj('/');
    $result=$test->getValue(23,0);
    echo $result;

工厂模式：
以交通工具为例子：要求请既可以定制交通工具，又可以定制交通工具生产的过程
1>定制交通工具
1.定义一个接口，里面包含交工工具的方法（启动 运行 停止）
2.让飞机，汽车等类去实现他们

2> 定制工厂（通上类似）
1.定义一个接口，里面包含交工工具的制造方法（启动 运行 停止）
2.分别写制造飞机，汽车的工厂类去继承实现这个接口



例二

有一部分基础数据，是类classA是从数据库A读取出来的，其他很多的功能都是基于这个基础数据来操作的。现在呢，我想把数据从数据库A变成从另外的数据源去获取，这时候，要修改起来就比较麻烦，要修改其他很多类的代码。这种设计显然是不够灵活的，换句话说，就是紧耦合的，系统中某个部分的函数或类严重依赖于系统的其他部分中的函数或类的行为和结构。

工厂模式，就是解决这样的一些情况的设计方法。工厂模式是一种类，建立了一个工厂来根据所需来创建对象，这种方式在多态性编程中是很重要的，允许动态替换类，修改配置等。

工厂模式分为：简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式，通过静态方法创建对象。可以理解成，只负责生产同一等级结构中的任何一个产品，但是不能新增产品。

工厂方法模式，去掉了简单工厂模式中方法的静态属性，使其可以被子类集成，定义一个创建对象的接口，让子类去决定实例化哪个类。可以理解成，用来生产同一等级结构中的固定产品，但是支持增加产品。

抽象工厂模式，提供一个创建一系列相关或者相互依赖的对象的接口。可以理解成，用来生产不用类型的全部产品，但是不能增加新品，支持增加新的类型。

<?php
/**
 * 基本工厂模式
 * */
class User { 
    private $username; 
    public function __construct($username) { 
        $this->username = $username; 
    } 
    
    public function getUser() { 
        return $this->username; 
    } 
}
 
class userFactory { 
    static public function createUser() { 
        return new User('Jack'); 
    } 
}
 
$user = userFactory::createUser();echo $user->getUser();
 
/**
 *简单工厂模式
 * */
interface userProperties {
    function getUsername();
    function getGender();
    function getJob();
}
class User implements userProperties{
    private $username;
    private $gender;
    private $job;
    public function __construct($username, $gender, $job) {
        $this->username = $username;
        $this->gender = $gender;
        $this->job = $job;
    }
 
    public function getUsername() {
        return $this->username;
    }
 
    public function getGender() {
        return $this->gender;
    }
 
    public function getJob() {
        return $this->job;
    }
}
 
class userFactory {
    static public function createUser($properties = []) {
        return new User($properties['username'], $properties['gender'], $properties['job']);
    }
}
 
$employers = [
    ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
    ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
    ];
$user = userFactory::createUser($employers[0]);
echo $user->getUsername();
 
/**
 * 工厂方法模式
 **/
interface userProperties {
    function getUsername();
    function getGender();
    function getJob();
}
 
interface createUser {
    function create($properties);
}
 
class User implements userProperties{
    private $username;
    private $gender;
    private $job;
    public function __construct($username, $gender, $job) {
        $this->username = $username;
        $this->gender = $gender;
        $this->job = $job;
    }
 
    public function getUsername() {
        return $this->username;
    }
 
    public function getGender() {
        return $this->gender;
    }
 
    public function getJob() {
        return $this->job;
    }
}
 
class userFactory {
    private $user;
    public function __construct($properties = []) {
        $this->user =  new User($properties['username'], $properties['gender'], $properties['job']);
    }
 
    public function getUser() {
        return $this->user;
    }
}
 
class FactoryMan implements createUser {
    function create($properties) {
        return new userFactory($properties); 
    }
} 
 
class FactoryWoman implements createUser {
    function create($properties) {
        return new userFactory($properties);
    }
}
 
class clientUser {
    static public function getClient($properties) {
        $fac = new FactoryMan;
        $man = $fac->create($properties);
        echo $man->getUser()->getUsername();
    }
}
 
$employers = [
    ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
    ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
    ];
$user = clientUser::getClient($employers[0]);
 
/**
 * 抽象工厂模式
 * */
 
interface userProperties {
    function getUsername();
    function getGender();
    function getJob();
}
 
interface createUser { //将对象的创建抽象成一个接口
    function createOpen($properties);//内向创建
    function createIntro($properties);//外向创建
}
 
class User implements userProperties{
    private $username;
    private $gender;
    private $job;
    public function __construct($username, $gender, $job) {
        $this->username = $username;
        $this->gender = $gender;
        $this->job = $job;
    }
 
    public function getUsername() {
        return $this->username;
    }
 
    public function getGender() {
        return $this->gender;
    }
 
    public function getJob() {
        return $this->job;
    }
}
 
class userFactory {
    private $user;
    public function __construct($properties = []) {
        $this->user =  new User($properties['username'], $properties['gender'], $properties['job']);
    }
 
    public function getUser() {
        return $this->user;
    }
}
 
class FactoryMan implements createUser {
    function createOpen($properties) {
        return new userFactory($properties); 
    }
 
    function createIntro($properties) {
        return new userFactory($properties); 
    }
} 
 
class FactoryWoman implements createUser {
    function createOpen($properties) {
        return new userFactory($properties);
    }
 
    function createIntro($properties) {
        return new userFactory($properties);
    }
}
 
class clientUser {
    static public function getClient($properties) {
        $fac = new FactoryMan;
        $man = $fac->createOpen($properties);
        echo $man->getUser()->getUsername();
    }
}
 
$employers = [
    ['username' => 'Jack', 'gender' => 'male', 'job' => 'coder'],
    ['username' => 'Marry', 'gender' => 'female', 'job' => 'designer'],
    ];
$user = clientUser::getClient($employers[0]);

例三

工厂这个词的使用是非常形象，字面意思可以这样认为，这种模式下，我们有一个工厂，这个工厂生产很多一种或者几种产品（其实多种的情况是覆盖了一种的），但是每个产品怎么生产和包装的我们不知道，其实我们也不需要知道，知道的越多你就越迷糊，以后你的行为就受制于太多杂事，也就是我们常说的耦合度太高，因此我们就将所有的事情交给工厂负责，我们只用告诉工厂需要什么，工厂把产品交付给你就是了。一旦产品的工艺发生改变，工厂负责就好，你使用该产品的工艺不受影响。因此工厂模式可以大大的降低系统的耦合度，增强系统的稳定性，当然也会提高代码的复用率。

在实际的程序设计中，工厂相当于一个对外的接口，那么这个接口的返回类型是确定的，那么我们怎么通过这个工厂来生产不同的产品发回给客户呢？很简单，做一个所有产品的“模子”就可以，这个“模子”有每个产品的所有特征，但是不能用，需要具体的产品实现这些特性，就是我们常说的Interface。

编写一个接口 Product.php

<?php

interface Product{
    public function getName();
}

设计一个产品A实现Product接口

<?php

class ProductA implements Product{

    public function getName(){
        // TODO: Implement getName() method.
        echo '我是产品A';
    }
}

设计产品B实现Product接口

<?php

class ProductB implements Product{

    public function getName(){
        // TODO: Implement getName() method.
        echo '我是产品B';
    }

}

建造一座工厂生产产品A和B

<?php

class ProductFactory{

    /**
     * @param $product_name
     * @return mixed
     */
    public function factory($product_name){
        return new $product_name; //PHP可以使用名字直接new一个同名的对象这个很方便
    }

}

产品A和B已经设计好了，工厂也建好了，下一步就是测试一下这个工厂对的生产能力如何。

<?php

include 'ProductFactory.php';
include 'Product.php';
include 'ProductA.php';
include 'ProductB.php';

$factory = new  ProductFactory();
echo $factory->factory('ProductA')->getName().PHP_EOL;
echo $factory->factory('ProductB')->getName();

猜你喜欢

转载自blog.csdn.net/ahaotata/article/details/83660752
今日推荐
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
周排行
阿里云短信服务平台注册
Windows下的字符串处理(1)
sqoop: mysql导入数据到hdfs, hive, hbase
commons.lang中常用的工具类
离线安装PostgreSQL11.6
使用PyTorch简单实现卷积神经网络模型
一文彻底搞定谱聚类
一道面试题引发的血案
One Chat for Mac(聊天工具)
TCP/IP的底层队列是如何实现的？
每日归档
更多
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022