大话PHP设计模式之创建型

最新推荐文章于 2021-03-11 13:22:20 发布
最新推荐文章于 2021-03-11 13:22:20 发布
阅读量176 收藏
点赞数
文章标签： 大话PHP设计模式 PHP设计模式之创建型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mutou_ren123/article/details/100292387
版权

<?php
/**
 * 单例模式（Singleton）
 * 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
 */
class Singleton
{
    /**
    * @var Singleton
    */
    private static $instance;

    /**
    * 不允许从外部调用以防止创建多个实例
    * 要使用单例，必须通过 Singleton::getInstance() 方法获取实例
    */
    private function __construct()
    {
    }

    /**
    * 通过懒加载获得实例（在第一次使用的时候创建）
    */
    public static function getInstance(): Singleton
    {
        if (null === static::$instance) {
            static::$instance = new static();
        }

        return static::$instance;
    }

    /**
    * 防止实例被克隆（这会创建实例的副本）
    */
    private function __clone()
    {
    }

    /**
    * 防止反序列化（这将创建它的副本）
    */
    private function __wakeup()
    {
    }
}
?>

<?php 
/**
 * 多例模式（Multiton）
 * 多例模式：在多例模式中，多例类可以有多个实例，而且多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。
 * 1. 通过实例容器保存容器。2. 利用私有构造阻止外部构造。3. 提供getInstantce()方法获取实例.
 */
abstract class Multiton { 

    private static $instances = array(); 
    
    public static function getInstance() { 
        $key = get_called_class() . serialize(func_get_args());
        if (!isset(self::$instances[$key])) { 
            $rc = new ReflectionClass(get_called_class());
            self::$instances[$key] = $rc->newInstanceArgs(func_get_args());
        }
        return self::$instances[$key]; 
    }

    /**
     * 该私有对象阻止实例被克隆
     */
    private function __clone()
    {
    }

    /**
     * 该私有方法阻止实例被序列化
     */
    private function __wakeup()
    {
    }
} 

class Hello extends Multiton { 
    public function __construct($string = 'World') { 
        echo "Hello $string\n"; 
    } 
} 

class GoodBye extends Multiton { 
    public function __construct($string = 'my', $string2 = 'darling') { 
        echo "Goodbye $string $string2\n"; 
    }
}

$a = Hello::getInstance('World'); 
$b = Hello::getInstance('bob'); 
// $a !== $b 

$c = Hello::getInstance('World'); 
// $a === $c 

$d = GoodBye::getInstance(); 
$e = GoodBye::getInstance();
// $d === $e 

$f = GoodBye::getInstance('your'); 
// $d !== $f 

?>

<?php
/**
 * 工厂方法模式（Factory Method）
 * 将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。
 * 背景：小成有一间塑料加工厂（仅生产A类产品）；随着客户需求的变化，客户需要生产B类产品；
 * 冲突：改变原有塑料加工厂的配置和变化非常困难，假设下一次客户需要再发生变化，再次改变将增大非常大的成本；
 * 解决方案：小成决定置办塑料分厂B来生产B类产品；
 * 原文链接：https://www.jb51.net/article/39037.htm
 */
abstract class Product{
    public abstract function Show();
}

//具体产品A类
class  ProductA extends  Product{
    public function Show() {
        echo "生产出了产品A";
    }
}

//具体产品B类
class  ProductB extends  Product{
    public function Show() {
        echo "生产出了产品B";
    }
}

abstract class Factory{
    public abstract function Manufacture();
}

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    public function Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    public function Manufacture() {
        return new ProductB();
    }
}

?>

<?php
/**
 *抽象工厂模式（Abstract Factory）
 *有些情况下我们需要根据不同的选择逻辑提供不同的构造工厂，而对于多个工厂而言需要一个公共的抽象工厂标准
 *Product 定义抽象工厂标准
 *ShippableProduct 可运输产品 DigitalProduct 数码产品
 *ProductFactory 负责加载相对应产品
 *AbstractFactoryTest 测试类
 */
interface Product
{
    public function calculatePrice(): int;
}

class ShippableProduct implements Product
{
    /**
     * @var float
     */
    private $productPrice;
    /**
     * @var float
     */
    private $shippingCosts;
    public function __construct(int $productPrice, int $shippingCosts)
    {
        $this->productPrice = $productPrice;
        $this->shippingCosts = $shippingCosts;
    }
    public function calculatePrice(): int
    {
        return $this->productPrice + $this->shippingCosts;
    }
}

class DigitalProduct implements Product
{
    /**
     * @var int
     */
    private $price;
    public function __construct(int $price)
    {
        $this->price = $price;
    }
    public function calculatePrice(): int
    {
        return $this->price;
    }
}

class ProductFactory
{
    const SHIPPING_COSTS = 50;
    public function createShippableProduct(int $price): Product
    {
        return new ShippableProduct($price, self::SHIPPING_COSTS);
    }
    public function createDigitalProduct(int $price): Product
    {
        return new DigitalProduct($price);
    }
}

//测试类
class AbstractFactoryTest
{
    public function testCanCreateDigitalProduct(): bool
    {
        $factory = new ProductFactory();
        $product = $factory->createDigitalProduct(150);
        return new DigitalProduct(150) == $product;
    }
    public function testCanCreateShippableProduct(): bool
    {
        $factory = new ProductFactory();
        $product = $factory->createShippableProduct(150);
        return new ShippableProduct(150,50) == $product;
    }
    public function testCanCalculatePriceForDigitalProduct(): bool
    {
        $factory = new ProductFactory();
        $product = $factory->createDigitalProduct(150);
        return 150 == $product->calculatePrice();
    }
    public function testCanCalculatePriceForShippableProduct(): bool
    {
        $factory = new ProductFactory();
        $product = $factory->createShippableProduct(150);
        return 200 == $product->calculatePrice();
    }
}

$abFactoryTest = new AbstractFactoryTest();
var_dump($abFactoryTest->testCanCreateDigitalProduct());
var_dump($abFactoryTest->testCanCreateShippableProduct());
var_dump($abFactoryTest->testCanCalculatePriceForDigitalProduct());
var_dump($abFactoryTest->testCanCalculatePriceForShippableProduct());
/**
bool(true)
bool(true)
bool(true)
bool(true)
*/

?>

<?php

/**
 * 简单工厂模式（Simple Factory）
 * 简单工厂模式是一个精简版的工厂模式。
 * 它与静态工厂模式最大的区别是它不是『静态』的。因为非静态，所以你可以拥有多个不同参数的工厂，你可以为其创建子类
 * 工厂角色-具体产品-抽象产品
 * 一个事例
 * 一个农场，要向市场销售水果
 * 农场里有三种水果 苹果、葡萄
 * 我们设想：1、水果有多种属性，每个属性都有不同，但是，他们有共同的地方 |  生长、种植、收货、吃
 * 2、将来有可能会增加新的水果、我们需要定义一个接口来规范他们必须实现的方法
 * 3、我们需要获取某个水果的类，要从农场主那里去获取某个水果的实例，来知道如何生长、种植、收货、吃
 * 原文链接：https://www.cnblogs.com/aqsmoke/p/3955310.html
 */
interface fruit{
    /**
     * 生长
     */
    public function grow();
    /**
     * 种植
     */
    public function plant();
    /**
     * 收获
     */
    public function harvest();
    /**
     * 吃
     */
    public function eat();
}


/**
 * 定义具体产品类 苹果
 * 首先，我们要实现所继承的接口所定义的方法
 * 然后定义苹果所特有的属性，以及方法
 */
class apple implements fruit{

    //苹果树有年龄
    private $treeAge;

    //苹果有颜色
    private $color;

    public function grow(){
        echo "grape grow";
    }

    public function plant(){
        echo "grape plant";
    }

    public function harvest(){
        echo "grape harvest";
    }

    public function eat(){
        echo "grape eat";
    }

    //取苹果树的年龄
    public function getTreeAge(){
        return $this->treeAge;
    }

    //设置苹果树的年龄
    public function setTreeAge($age){
        $this->treeAge = $age;
        return true;
    }

}

/**
 * 定义具体产品类 葡萄
 * 首先，我们要实现所继承的接口所定义的方法
 * 然后定义葡萄所特有的属性，以及方法
 */
class grape implements fruit{


    //葡萄是否有籽
    private $seedLess;

    public function grow(){
        echo "apple grow";
    }

    public function plant(){
        echo "apple plant";
    }

    public function harvest(){
        echo "apple harvest";
    }

    public function eat(){
        echo "apple eat";
    }

    //有无籽取值
    public function getSeedLess(){
        return $this->seedLess;
    }

    //设置有籽无籽
    public function setSeedLess($seed){
        $this->seedLess = $seed;
        return true;
    }

}


/**
 *农场主类 用来获取实例化的水果
 *
 */
class farmer{

    //定义个静态工厂方法
    public static function factory($fruitName){
        switch ($fruitName) {
            case 'apple':
                return new apple();
                break;
            case 'grape':
                return new grape();
                break;
            default:
                throw new badFruitException("Error no the fruit", 1);
                break;
        }
    }
}

class badFruitException extends Exception{
    public $msg;
    public $errType;
    public function __construct($msg = '' , $errType = 1){
        $this->msg = $msg;
        $this->errType = $errType;
    }  
}


/**
 * 获取水果实例化的方法
 */
try{
    $appleInstance = farmer::factory('apple');
    var_dump($appleInstance);
}catch(badFruitException $err){
    echo $err->msg . "_______" . $err->errType;
}

?>

<?php
/**
 * 原型模式（Prototype）
 * 相比正常创建一个对象 (new Foo () )，首先创建一个原型，然后克隆它会更节省开销。
 */
abstract class BookPrototype
{
    /**
    * @var string
    */
    protected $title = 0;

    /**
    * @var string
    */
    protected $category;

    abstract public function __clone();

    public function getTitle(): string
    {
        return $this->title;
    }

    public function setTitle($title)
    {
       $this->title = $title;
    }
}

class BarBookPrototype extends BookPrototype
{
    /**
    * @var string
    */
    protected $category = 'Bar';

    public function __clone()
    {
    }
}

class FooBookPrototype extends BookPrototype
{
    /**
    * @var string
    */
    protected $category = 'Foo';

    public function __clone()
    {
    }
}

$fooPrototype = new FooBookPrototype();
$barPrototype = new BarBookPrototype();

for ($i = 5; $i < 10; $i++) {
    $book = clone $fooPrototype;
    $book->setTitle('Foo Book No ' . $i);
    var_dump(new FooBookPrototype == $book);
}

for ($i = 0; $i < 5; $i++) {
    $book = clone $barPrototype;
    $book->setTitle('Bar Book No ' . $i);
    var_dump(new BarBookPrototype == $book);
}

?>

<?php
/**
 * 对象池模式（Pool）
 * 对象池可以用于构造并且存放一系列的对象并在需要时获取调用
 * 在初始化实例成本高，实例化率高，可用实例不足的情况下，对象池可以极大地提升性能。在创建对象（尤其是通过网络）时间花
 * 销不确定的情况下，通过对象池在可期时间内就可以获得所需的对象。
 * 转自：https://segmentfault.com/a/1190000003817321
 */
class Product {
 
    protected $id;
 
    public function __construct($id) {
        $this->id = $id;
    }
 
    public function getId() {
        return $this->id;
    }
}
 
class Factory {
 
    protected static $products = array();
 
    public static function pushProduct(Product $product) {
        self::$products[$product->getId()] = $product;
    }
 
    public static function getProduct($id) {
        return isset(self::$products[$id]) ? self::$products[$id] : null;
    }
 
    public static function removeProduct($id) {
        if (array_key_exists($id, self::$products)) {
            unset(self::$products[$id]);
        }
    }
}
 
Factory::pushProduct(new Product('first'));
Factory::pushProduct(new Product('second'));
 
print_r(Factory::getProduct('first')->getId());
// first
print_r(Factory::getProduct('second')->getId());
// second

?>

<?php
/**
 * 建造者模式（Builder）
 * Director 类是建造者模式的一部分。 它可以实现建造者模式的接口
 * 并在构建器的帮助下构建一个复杂的对象
 *
 * Director 导演者,负责构建
 * BuilderInterface 构建接口,规范建造标准
 * TruckBuilder 构建卡车类 CarBuilder 构建汽车类
 * Vehicle 零部件公共类
 * Truck Car Engine Wheel Door 构建零部件
 * DirectorTest 测试类
 */ 
class Director
{
    public function build(BuilderInterface $builder): Vehicle
    {
        $builder->createVehicle();
        $builder->addDoors();
        $builder->addEngine();
        $builder->addWheel();

        return $builder->getVehicle();
    }
}

interface BuilderInterface
{
    public function createVehicle();
    public function addWheel();
    public function addEngine();
    public function addDoors();
    public function getVehicle(): Vehicle;
}

class TruckBuilder implements BuilderInterface
{
    /**
    * @var Truck
    */
    private $truck;

    public function addDoors()
    {
        $this->truck->setPart('rightDoor', new Door());
        $this->truck->setPart('leftDoor', new Door());
    }

    public function addEngine()
    {
        $this->truck->setPart('truckEngine', new Engine());
    }

    public function addWheel()
    {
        $this->truck->setPart('wheel1', new Wheel());
        $this->truck->setPart('wheel2', new Wheel());
        $this->truck->setPart('wheel3', new Wheel());
        $this->truck->setPart('wheel4', new Wheel());
        $this->truck->setPart('wheel5', new Wheel());
        $this->truck->setPart('wheel6', new Wheel());
    }

    public function createVehicle()
    {
        $this->truck = new Truck();
    }

    public function getVehicle(): Vehicle
    {
        return $this->truck;
    }
}

class CarBuilder implements BuilderInterface
{
    /**
    * @var Car
    */
    private $car;

    public function addDoors()
    {
        $this->car->setPart('rightDoor', new Door());
        $this->car->setPart('leftDoor', new Door());
        $this->car->setPart('trunkLid', new Door());
    }

    public function addEngine()
    {
        $this->car->setPart('engine', new Engine());
    }

    public function addWheel()
    {
        $this->car->setPart('wheelLF', new Wheel());
        $this->car->setPart('wheelRF', new Wheel());
        $this->car->setPart('wheelLR', new Wheel());
        $this->car->setPart('wheelRR', new Wheel());
    }

    public function createVehicle()
    {
        $this->car = new Car();
    }

    public function getVehicle(): Vehicle
    {
        return $this->car;
    }
}

abstract class Vehicle
{
    /**
    * @var object[]
    */
    private $data = [];

    /**
    * @param string $key
    * @param object $value
    */
    public function setPart($key, $value)
    {
        $this->data[$key] = $value;
    }
}

class Truck extends Vehicle
{
}

class Car extends Vehicle
{
}

class Engine extends Vehicle
{
}

class Wheel extends Vehicle
{
}

class Door extends Vehicle
{
}

class DirectorTest
{
    public function testCanBuildTruck()
    {
        $truckBuilder = new TruckBuilder();
        return (new Director())->build($truckBuilder);
    }

    public function testCanBuildCar()
    {
        $carBuilder = new CarBuilder();
        return (new Director())->build($carBuilder);
    }
}

$directorTest = new DirectorTest();
var_dump($directorTest->testCanBuildTruck());
var_dump($directorTest->testCanBuildCar());

?>
 

无名花火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
大话设计模式之外观模式
02-03
大话设计模式之外观模式 经典代码 C#类
php+设计模式代码,PHP设计模式（创建型）
weixin_31623707的博客
03-11 98
前言随着编程项目经验的增加，从服务于业务逻辑到针对项目的全局设计。认识到设计模式在开发过程中 \的重要性，遵循 S.O.L.I.D 五大基准原则。它拓展了我的视野，让代码更加灵活，看起来更加富有美感.\美是构建万物的哲学思想.我们学习的设计模式分为三类：创建者模式、结构型模式、行为型模式；创建型模式与对象的创建有关；结构型模式处理类或对象的组合；而行为型模式是对类或对象怎样交互和怎样分配职责进行描...
关于TP5类的自动加载(spl_autoload_register)自我梳理
qq_23159841的博客
02-14 415
<?php // public\index.php // +---------------------------------------------------------------------- // | ThinkPHP [ WE CAN DO IT JUST THINK ] // +-------------------------------------------------...
关于TP5如何自动加载通过composer安装的类库
qq_23159841的博客
02-14 648
TP5自动加载composer主要是在tp5\thinkphp\library\think\Loader.php文件register里面实现的 <?php // +---------------------------------------------------------------------- // | ThinkPHP [ WE CAN DO IT JUST THINK ] ...
【thinkphp5源码分析】加载类Loader.php
深漂小码哥
08-21 1314
&lt;?php // +---------------------------------------------------------------------- // | ThinkPHP [ WE CAN DO IT JUST THINK ] // +---------------------------------------------------------------------...
tp5源码分析之自动加载
An丶的博客
02-23 1407
1 自动加载自动加载，在php中主要包括命名空间到目录的定位，类名到文件的定位。tp5的自动加载实现在Loader.php中。1 启动自动加载Loader::register()启动自动加载public static function register($autoload = '') { // 注册系统自动加载 spl_autoload_register($...
大话设计模式-完整设计模式介绍
10-23
大话设计模式 完整设计模式介绍
android之大话设计模式.pdf
07-13
android之大话设计模式.pdf
大话设计模式总结.pdf
03-29
大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf
vagrant的学习 之 ThinkPHP5.1
08-29 141
vagrant的学习 之 ThinkPHP5.1 本文根据慕课网的视频教程练习，感谢慕课网！ 慕课视频学习地址：https://www.imooc.com/video/14218。 慕课的参考文档地址：https://github.com/apanly/mooc/tree/master/va （1）下载ThinkPHP5.1的框架： 如果使用git克隆框架，需要先...
php.类与对象
weixin_33840661的博客
11-27 79
访问控制 属性和方法的访问控制（可见标识）：public 任何地方private 类自身protected 类自身，自子类及自父类 this this 可以理解为这个类的一个实例 self self 代表类本身 __construct 实例化时就会自动执行public function __construct() {} __destru...
PHP魔术方法的使用
zhengwish的专栏
06-23 2055
本文测试环境为 php5.5.12 一、__get 、__set     将对象的属性进行接管。     一般来说，总是把类的属性定义为private，但是对属性的读取和赋值操作非常频繁，在php5+，预定义__set() 和__get()来获取和赋值其属性。即私有成员的设置和取值操作。     这两个方法需要手动添加到类中。如下：      public function __s
php 抽象工厂模式,抽象工厂模式（Abstract Factory）
weixin_36451983的博客
03-10 73
1.1.1. 目的在不指定具体类的情况下创建一系列相关或依赖对象。 通常创建的类都实现相同的接口。 抽象工厂的客户并不关心这些对象是如何创建的，它只是知道它们是如何一起运行的。1.1.2. UML 图1.1.3. 代码你可以在GitHub 上找到这个代码。Product.phpnamespace DesignPatterns\Creational\AbstractFactory;interfac...
使用static来避免“重复读”
rethink log
09-21 123
在较复杂的web程序开发中，由于采用面向对象的数据操作方式，或者业务逻辑太过复杂，开发人员在开发过程中，经常会无意识的重复读取数据。比如：$result1 = tableobjectPeer::getResult($var1,$var2,$var3);开发人员在需要的该table数据的时候，经常直接调用 tableobjectPeer::getResult方法。又或者程序在进行forward()的...
PHP 工厂模式介绍
weixin_30636089的博客
06-22 107
工厂模式，顾名思义，如同工厂一样，你把原材料放入工厂中，出来的是成品，而你并不需要知道工厂里做了什么，工厂模式主要用于解耦。个人认为设计模式只能在实战中更好的理解，当前水平有限，欢迎大家交流 简单工厂模式 把对象的创建和使用的过程分开，比如： ClassA 调用 ClassB，那么 ClassA 只调用ClassB 的方法，至于实例化 ClassB 则在工厂内实现。这样既减少了代码的重复使用...
机器学习模型评估与优化：常用方法与实践技巧.md
08-15
机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器
强化学习算法介绍.docx
最新发布
08-15
强化学习
SpringBoot+Vue在线商城(电子商城)系统 java毕业设计 源码+sql脚本+论文 完整版
08-15
这个是完整源码 SpringBoot + Vue实现 SpringBoot+Vue在线商城(电子商城)系统 java毕业设计 源码+sql脚本+论文 完整版 数据库是mysql 随着互联网技术的发展和普及，电子商务在全球范围内得到了迅猛的发展，已经成为了一种重要的商业模式和生活方式。电子商城是电子商务的重要组成部分，是一个基于互联网的商业模式和交易平台，通过网络进行产品和服务的销售。电子商城已成为了线上交易和消费的主要方式，人们可以方便快捷地买到自己想要的商品和服务，并在家中享受线上购物的便利性和舒适性。 基于这个背景，我们决定开发一个功能强大、易于使用、可靠性高的商城系统，以满足用户在线购物的需求。这个商城系统将支持多种商品和服务的销售、多种支付方式和多种物流配送方式，提供优惠券和积分等扩展功能，为用户提供舒适的购物体验和服务。同时，我们还将采用最新的技术和开发模式，在保证系统稳定运行的同时，不断推出新的功能和特性，以满足用户不断增长的需求和期望。基于这个背景，我们决定开发一个功能强大、易于使用、可靠性高的商城系统，以满足用户在线购物的需求。这个商城系统将支持多种商品和服务的销售、多
大话设计模式 c++
09-13
在大话设计模式中，作者通过讲述故事的形式，生动地介绍了23种设计模式，包括创建型模式、结构型模式和行为型模式。其中创建型模式包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式；...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值