PHP factory model introduced

Factory mode, as the name suggests, like a factory, like, you convert the raw materials into the plant, it is finished, and you do not need to know what has been done in the factory. Code is similar, the main arguments in a factory, returns processed data, we do not need the factory did what only needs to know the value and the need to pass the value returned. Personally I think that design patterns can only be understood better in actual combat, the limited current levels, we welcome the exchange of

Simple factory pattern

<?php
namespace Factory\SimpleFactory;


class SimpleFactory
{
    public function createProduction(): Production
    {
        return new Production();
    }
}

class Production
{
    public function getPrice(int $price)
    {
        return $price * 2;
    }
}

class Test
{
    public function __construct()
    {
        $factory = new SimpleFactory();
        $production = $factory->createProduction();

        if ($production instanceof Production) {
            echo 'Nice';
        }
    }
}

Factory Method pattern

It restricted mainly used in public methods

<?php


namespace Factory\SimpleFactory;


/**
 * Interface FunctionFactory
 * @package Factory\SimpleFactory
 */
interface FunctionFactory
{
    /**
     * @param array $data
     * @return array
     */
    public function create(array $data);

    /**
     * @param int $id
     * @return bool
     */
    public function delete(int $id);

    /**
     * @param array $data
     * @return array
     */
    public function update(array $data);

    /**
     * @return array
     */
    public function select();
}

class ProductionRepository implements FunctionFactory
{
    public function create(array $data)
    {
        // TODO: Implement create() method.
    }

    public function delete(int $id)
    {
        // TODO: Implement delete() method.
    }

    public function update(array $data)
    {
        // TODO: Implement update() method.
    }

    public function select()
    {
        // TODO: Implement select() method.
    }
}

Abstract factory pattern

Factory method abstract factory pattern = pattern factory mode Easy +

<?php

namespace Factory\SimpleFactory;


/**
 * Class AbstractFactory
 * @package Factory\SimpleFactory
 */
class AbstractFactory
{
    /**
     * @param int $price
     * @param int $discount
     * @return PromotionPhoneProduct
     */
    public function createPromotionPhoneProduct(int $price, int $discount)
    {
        return new PromotionPhoneProduct($price, $discount);
    }

    /**
     * @param int $price
     * @return PhoneProduct
     */
    public function createPhoneProduct(int $price)
    {
        return new PhoneProduct($price);
    }
}

/**
 * Interface Product
 * @package Factory\SimpleFactory
 */
interface Product
{
    /**
     * @return int
     */
    public function calculatePrice(): int;
}

/**
 * Class PhoneProduct
 * @package Factory\SimpleFactory
 */
class PromotionPhoneProduct implements Product
{
    /**
     * @var int
     */
    private $price;

    /**
     * @var int
     */
    private $discount;

    /**
     * PhoneProduct constructor.
     * @param int $price
     * @param int $discount
     */
    public function __construct(int $price, int $discount)
    {
        $this->price = $price;
        $this->discount = $discount;
    }

    /**
     * @return int
     */
    public function calculatePrice(): int
    {
        return $this->price * $this->discount;
    }
}

/**
 * Class PhoneProduct
 * @package Factory\SimpleFactory
 */
class PhoneProduct implements Product
{
    /**
     * @var int
     */
    private $price;

    /**
     * PhoneProduct constructor.
     * @param int $price
     * @param
     */
    public function __construct(int $price)
    {
        $this->price = $price;
    }

    /**
     * @return int
     */
    public function calculatePrice(): int
    {
        return $this->price;
    }
}

Static factory method

Static method is mainly used in the construction of objects of the same type

<?php


namespace Factory\SimpleFactory;


/**
 * Class StaticFactory
 * @package Factory\SimpleFactory
 */
class StaticFactory
{
    /**
     * @param string $type
     * @return NumericClass|StringClass
     */
    public static function build(string $type)
    {
        switch ($type) {
            case 'string':
                return new StringClass();
                break;
            case 'numeric':
                return new NumericClass();
            default:
                break;
        }
    }
}

/**
 * Interface TypeInterface
 * @package Factory\SimpleFactory
 */
interface TypeInterface
{
    /**
     * @return mixed
     */
    public function getType();
}

/**
 * Class NumericClass
 * @package Factory\SimpleFactory
 */
class NumericClass implements TypeInterface
{
    /**
     * @return mixed|void
     */
    public function getType()
    {
        // TODO: Implement getType() method.
    }
}

/**
 * Class StringClass
 * @package Factory\SimpleFactory
 */
class StringClass implements TypeInterface
{
    /**
     * @return mixed|void
     */
    public function getType()
    {
        // TODO: Implement getType() method.
    }
}