当我要实例化类的时候，不直接new这个类，而是通过调用另一个类的方法来实例化，这就是工厂模式的核心，
就是用很多类，都是一种类型的，然后将这些类汇总在一个新的工厂类里边，工厂方法替你实例化，你想用哪个类，调用工厂类的方法，传入参数，就会返回你需要实例化的类，多了一个封装，类似switch干的活，
修改，增加改动比较少，统一控制，简化逻辑跟代码
工厂分为：简单工厂（静态工厂）、工厂方法模式，抽象工厂模式

简单工厂

其实简单工厂不属于23种设计模式，比较好理解，就是封装汇总

  1. /**
  2.  * 定义一个接口，规定方法
  3.  */
  4. interface Message
  5. {
  6.     public function send($msg);
  7. }
  9. //不同的类实现接口
  11. class Ali implements Message
  12. {
  13.     public function send($msg)
  14.     {
  15.         return '阿里短信->短信内容是：' . $msg;
  16.     }
  17. }
  19. class Txun implements Message
  20. {
  21.     public function send($msg)
  22.     {
  23.         return '腾讯短信->短信内容是：' . $msg;
  24.     }
  25. }
  27. class Bdu implements Message
  28. {
  29.     public function send($msg)
  30.     {
  31.         return '百度短信->短信内容是：' . $msg;
  32.     }
  33. }
  35. /**
  36.  * 工厂类
  37.  */
  38. class MessageFactory
  39. {
  40.     public static function CreateFactory($type)
  41.     {
  42.         switch ($type) {
  43.             case 'ali':
  44.                 return new Ali();
  45.                 break;
  46.             case 'tengxun':
  47.                 return new Txun();
  48.                 break;
  49.             case 'baidu':
  50.                 return new Bdu();
  51.                 break;
  52.             default:
  53.                 return null;
  54.                 break;
  55.         }
  56.     }
  57. }
  59. //使用简单工厂
  60. $messages = MessageFactory::CreateFactory('tengxun');
  61. echo $messages->send('你好，我叫大白');
  62. //输出    腾讯短信->短信内容是：你好，我叫大白
  1. 不用一定要使用static静态方法，根据需要来，可以new 然后调用<br />可以不用接口定义，只是为了规范一下，可以各个独立的类，方法一样就行<br />增加类，只需要增加对应的类文件  ,增加工厂类 switch 的type 就行，

工厂方法模式

工厂方法模式对比简单工厂，最核心的一点就是，将实现推迟到了子类中，将简单工厂当作父类，然后子类继承，实现功能，原本的父类的静态方法，变为抽象方法，子类实现这个方法，去掉的switch判断，子类直接返回实例化对象

  1. /**
  2.  * 定义一个接口，规定方法
  3.  */
  4. interface Message
  5. {
  6.     public function send($msg);
  7. }
  9. //不同的类实现接口
  11. class Ali implements Message
  12. {
  13.     public function send($msg)
  14.     {
  15.         return '阿里短信->短信内容是：' . $msg;
  16.     }
  17. }
  19. class Txun implements Message
  20. {
  21.     public function send($msg)
  22.     {
  23.         return '腾讯短信->短信内容是：' . $msg;
  24.     }
  25. }
  27. class Bdu implements Message
  28. {
  29.     public function send($msg)
  30.     {
  31.         return '百度短信->短信内容是：' . $msg;
  32.     }
  33. }
  35. /**
  36.  * 工厂类
  37.  */
  38. abstract class MessageFactory
  39. {
  40.     //抽象工厂方法
  41.     abstract protected function CreateFactory();
  43.     //返回实例化后的类
  44.     public function Operation()
  45.     {
  46.         return $this->CreateFactory();
  47.     }
  48. }
  50. //抽象实现子类
  51. class MessageAli extends MessageFactory
  52. {
  53.     public function CreateFactory()
  54.     {
  55.         return new Ali();
  56.     }
  57. }
  59. class MessageTxun extends MessageFactory
  60. {
  61.     public function CreateFactory()
  62.     {
  63.         return new Txun();
  64.     }
  65. }
  67. class MessageBdu extends MessageFactory
  68. {
  69.     public function CreateFactory()
  70.     {
  71.         return new Bdu();
  72.     }
  73. }
  75. //使用抽象方法工厂
  76. $Factory = new MessageAli();
  77. $messages = $Factory->Operation();
  78. echo $messages->send('你好，我叫大白');

抽象工厂模式

抽象工厂模式跟工厂方法模式相比，一样都是延迟到子类执行，一样返回指定对象，只是抽象工厂里面返回的不只是一个对象，而是多个

  1. <?php
  3. /**
  4. * 定义一个接口，规定方法
  5. */
  6. interface Message
  7. {
  8.   public function send($msg);
  9. }
  11. //不同的类实现接口
  13. class Ali implements Message
  14. {
  15.  public function send($msg)
  16.   {
  17.     return '阿里短信->短信内容是：'.$msg;
  19.   }
  20. }
  22. class Txun implements Message
  23. {
  24.  public function send($msg)
  25.   {
  26.     return '腾讯短信->短信内容是：'.$msg;
  28.   }
  29. }
  31. class Bdu implements Message
  32. {
  33.  public function send($msg)
  34.   {
  35.     return '百度短信->短信内容是：'.$msg;
  37.   }
  38. }
  40. /**
  41. * 定义另外一个接口，规定方法
  42. */
  43. interface Message2
  44. {
  45.   public function send($msg);
  46. }
  48. //不同的类实现接口
  50. class Ali2 implements Message2
  51. {
  52.  public function send($msg)
  53.   {
  54.     return '阿里短信本分->短信内容是：'.$msg;
  56.   }
  57. }
  59. class Txun2 implements Message2
  60. {
  61.  public function send($msg)
  62.   {
  63.     return '腾讯短信本分->短信内容是：'.$msg;
  65.   }
  66. }
  68. class Bdu2 implements Message2
  69. {
  70.  public function send($msg)
  71.   {
  72.     return '百度短信本分->短信内容是：'.$msg;
  74.   }
  75. }
  77. /**
  78. * 工厂类接口
  79. */
  80. interface MessageFactory
  81. {
  82.   //抽象工厂方法
  83.   public function CreateFactory();
  84.   //抽象工厂方法
  85.   public function CreateFactory2();
  87. }
  89. //抽象实现子类
  90. class MessageAli implements MessageFactory
  91. {
  92.  public function CreateFactory()
  93.   {
  94.     return new Ali();
  95.   }
  96.   public function CreateFactory2()
  97.   {
  98.     return new Ali2();
  99.   }
  100. }
  102. class MessageTxun implements MessageFactory
  103. {
  104.  public function CreateFactory()
  105.   {
  106.     return new Txun();
  107.   }
  108.     public function CreateFactory2()
  109.   {
  110.     return new Txun2();
  111.   }
  112. }
  114. class MessageBdu implements MessageFactory
  115. {
  116.  public function CreateFactory()
  117.   {
  118.    return new Bdu();
  119.   }
  120.     public function CreateFactory2()
  121.   {
  122.     return new Bdu2();
  123.   }
  124. }
  126. //使用抽象方法工厂
  127. $Factory= new MessageAli();
  128. $messages=$Factory->CreateFactory();
  129. $messages2=$Factory->CreateFactory2();
  130. echo $messages->send('你好，我叫大白');
  131. echo $messages2->send('你好，我叫大白');
  1. 就是子类里面实例化的对象，变为了多个，