设计模式之工厂模式

设计模式之——工厂模式

• 工厂模式之—简单工厂
  简单工厂的作用是将变化的部分分离出来，当代码使用了大量的具体类的时候会出现很大的麻烦，因为一旦加入了新的具体类，就必须改变代码，也就是说，你的代码并非对修改关闭，所以我们可以使用简单工厂来把变化的部分分离出来，使他们不会干扰应用的其他部分。
  未使用时：
  public class PizzaStore{
  Pizza orderPizza(String type){
  Pizza pizza;
  //变化部分开始—-
  if(type.equals(‘cheese’)){
  pizza = new CheesePizza();
  }else if(type.rquals(‘greek’)){
  pizza = new new GreekPizza();
  }
  //变化部分结束—-
  pizza.prepare();
  return pizza;
  }
  }
  使用后：
  class SImplePizzaFactory{
  public Pizza createPizza(String type){
  Pizza pizza = null;
  if(type.equals(‘cheese’)){
  pizza = new CheesePizza();
  }else if(type.rquals(‘greek’)){
  pizza = new new GreekPizza();
  }
  return pizza;
  }
  }
  public class PizzaStore{
  SimplePizzaFactory factory;
  public PizzaStore(SimplePizzaFactory factory){
  this.factory = factory;
  }
  Pizza orderPizza(String type){
  Pizza pizza;
  //变化部分开始—-
  pizza = factory.createPizza(type);
  //变化部分结束—-
  pizza.prepare();
  return pizza;
  }
  }
  通过简单工厂我们将原来创建Pizza的代码隔离了出去，消除了PizzaStore对于具体pizza的依赖，这样一旦有新的pizza产品时我们只需要更改SimplePizzaFactory。实现了PizzaStore的对修改关闭的原则。然而，简单工厂有它的局限性，当对象之间的关系变的复杂的时候，简单工厂将会显得笨拙，而且没有良好的扩展性。

• 工厂模式之工厂方法：
  在之前的SimplePizzaFactory中，我们将Pizza的制作方式固定在了PizzaStore中，但是这么做是没有弹性的，但是我们又希望各个不同的地区按照我们的指定的流程来加工Pizza,听起来很矛盾，怎样才能让Pizza的制作活动局限在PizzaStore中的同时又可以让不同地区可以制作出自己地区的风味呢？
  这时可以采用功工厂方法模式，我们需要做的就是把createPizza方法放回PizzaStore中，并把它设为抽象方法，然后为每个地区创建一个独有的PizzaStore子类。
  PizzaStore的改变：
  public abstract class PizzaStore{
  public Pizza orderPizza(String type){
  Pizza pizza;
  pizza = createPizza(type);
  pizza.prepare();
  pizza.bake();
  return pizza;
  }
  abstract Pizza createPizza(String type);
  }
  //工厂一
  public class NYPizzaStore extends PizzaStore{
  Pizza createPizza(String type){
  Pizza pizza = null;
  if(type.equals(‘cheese’)){
  pizza = new NYStyleCheesePizza();
  }else if(type.rquals(‘greek’)){
  pizza = new new NyStyleGreekPizza();
  }
  return pizza;
  }
  }
  //工厂二
  public class CHPizzaStore extends PizzaStore{
  Pizza createPizza(String type){
  Pizza pizza = null;
  if(type.equals(‘cheese’)){
  pizza = new CHStyleCheesePizza();
  }else if(type.rquals(‘greek’)){
  pizza = new new CHStyleGreekPizza();
  }
  return pizza;
  }
  }
  所有的工厂模式都是用来封装对象的创建，工厂方法模式通过子类决定该创建的对象是什么，来达到讲对象创建的过程封装的目的，其中PizzaStore是创造者类，它是一个抽象类，定义了有个抽象方法，让子类实现此方法创建产品，创建者通常会包含依赖于抽象产品的代码，而这些抽象产品由子类创造，创造这不需要知道在制造哪种具体的产品就。Pizza是产品类，它是一个抽象类，派生的子类为实际生产中需要的对象。
  工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类。所谓的“决定”，并不是指模式允许子类本身在运行时做决定，而是指在编写创建者类时，不需要知道实际创建的产品是哪一个，选择了使用妈个子类，自然就决定了实际创建的产品是什么。

• 工厂模式之抽象工厂：
  从工厂方法模式中我们可以看出，它适合对单一的产品进行生产，而当需要一个产品家族时，我们应当使用抽象工厂模式，抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类，这样一来，客户就从具体的产品中解耦，抽象工厂中的每一个方法实际看起来都像是工厂方法，每个方法负责创建一个具体的产品。
  //作料抽象工厂
  PizzaIngredientFactory{
  createDough();
  createSaurce();
  }
  //具体作料工厂一
  NYPizzaIngredientFactory implements PizzaIngredientFactory{
  createDough(){…};
  createSaurce(){…};
  }
  //具体作料工厂二
  CHPizzaIngredientFactory implements PizzaIngredientFactory{
  createDough(){…};
  createSaurce(){…};
  }
  //Pizza类修改为接收一个作料工厂
  Pizza{
  …
  PizzaIngredientFactory factory;
  Pizza(PizzaIngredientFactory factory){
  this.factory = factory;
  }
  prepare(){
  dough = factory.createDough();
  …..
  }
  }

因为我们需要一个佐料产品家族，我们把PizzaIngredientFactory实现为抽象工厂，每个子类都使用其地区的供货商来实现这些作料，每个作料都创建一个抽象类或接口接收工场返回的作料，这样Pizza中对于作料需求的实现通过工厂来获取作料，不管具体返回的是何地区的作料，做到了对抽象的实现而不是对具体的实现，做到了解耦合。

• 变成原则
  依赖倒置，依赖抽象不要依赖具体类

---

内容来源：head firsst design pattern