Detailed explanation of simple factory pattern of php design pattern, detailed explanation of php design pattern

Detailed explanation of simple factory pattern of php design pattern, detailed explanation of php design pattern_PHP tutorial

WBOY

Release： 2016-07-13 10:19:24

Original

787 people have browsed it

Detailed explanation of simple factory pattern of php design pattern, detailed explanation of php design pattern

This article introduces the simple factory pattern of PHP design pattern in more detail in the form of examples, which is a good reference for PHP program design. The details are as follows:

1. Concept

Simple Factory Pattern [Static Factory Method Pattern] (Static Factory Method)
Is the creation mode of the class

Several forms of factory pattern:

1. Simple Factory Pattern (Simple Factory) is also called Static Factory Method Pattern (Static Factory Method)

2. Factory Method is also called Polymorphic Factory

3. Abstract Factory pattern (Abstract Factory) is also called ToolKit pattern (ToolKit)

2. Picture analysis:

3. Code examples

The example code has been tested and can be run, as follows:

<&#63;php
/**
 * 一个事例
 *
 * 一个农场，要向市场销售水果
 * 农场里有三种水果 苹果、葡萄
 * 我们设想：1、水果有多种属性，每个属性都有不同，但是，他们有共同的地方 | 生长、种植、收货、吃
 *       2、将来有可能会增加新的水果、我们需要定义一个接口来规范他们必须实现的方法
 *       3、我们需要获取某个水果的类，要从农场主那里去获取某个水果的实例，来知道如何生长、种植、收货、吃
 */


/**
 * 虚拟产品接口类
 * 定义好需要实现的方法
 */

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 trie;
  }

}

/**
 * 定义具体产品类 葡萄
 * 首先，我们要实现所继承的接口所定义的方法
 * 然后定义葡萄所特有的属性，以及方法
 */
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;
}

Copy after login

I hope the examples described in this article will be helpful to everyone in PHP programming.

php design pattern: Write PHP5 sample code for factory mode and monomorphic mode

Example #1 Call factory method (with parameters)

class Example
{
// The parameterized factory method
public static function factory($ type)
{
if (include_once 'Drivers/' . $type . '.php') {
$classname = 'Driver_' . $type;
return new $classname;
} else {
throw new Exception ('Driver not found');
}
}
}
?>
------------ --------------------------
Example #2 Singleton mode

class Example
{
// Save the class instance in this attribute
private static $instance;

// The constructor is declared private to prevent direct creation of objects
private function __construct()
{
echo 'I am constructed';
}

// singleton method
public static function singleton()
{
if (!isset(self:: $instance)) {
$c = __CLASS__;
self::$instance = new $c;
}

return self::$instance;
}

// Ordinary methods in the Example class
public function bark()
{
echo 'Woof!';
}

// Prevent users from copying object instances
public function __clone()
{
trigger_error('Clone is not allowed.', E_USER_ERROR);
}

}

?>

Design Pattern Simple Factory Pattern

Factory refers to the place where instances are produced. Then just make it simple and name it directly createInstance(). This method is usually static and takes parameters and a return value. For example: For example, cows, sheep, horses, and dogs all inherit the animal class, then the return value of createInstance() should be animal (because the factory is to produce animals, so the return value should also be animal), and the parameter should be the name of the animal. (This way the factory will know what kind of animal you want to produce based on the name). In this way, an animal instance can be generated based on the passed in animal name. Implementation of createInstance: switch (animal name) case cow: return new cow (); case sheep: return new sheep (); case horse: return new horse (); case dog: return new dog ();