设计模式 5 —— 工厂模式

设计模式目录：

设计模式 1 ——观察者模式

设计模式 2 —— 装饰者模式 

设计模式 3 —— 迭代器和组合模式（迭代器）

设计模式 4 —— 迭代器和组合模式（组合）

设计模式 5 —— 工厂模式

设计模式 6 —— 单件模式

设计模式 7 —— 命令模式

设计模式 8 —— 适配器和外观模式

设计模式 9 —— 模板方法模式

设计模式 10 —— 状态模式

 

概述：

第1部分 简单工厂模式

   1.1 基本定义

   1.2 简单工厂模式实现

   1.3 优缺点和使用场景

第2部分 工厂模式

   2.1 问题引入

   2.2 基本定义

   2.3 工厂方法模式实现

   2.4 工厂方法模式优缺点和应用场景 

第3部分 抽象工厂模式

   3.1 问题引入

   3.2 基本定义

   3.3 抽象工厂模式实现

 

第1部分 简单工厂模式

在设计原则中有这样一句话“我们应该针对接口编程，而不是针对实现编程”。但是我们还是在一直使用new关键字来创建一个对象，这不就是在针对实现编程么？

        针对接口编程，可以隔离掉以后系统可能发生的一大堆改变。入股代码是针对接口而写，那么可以通过多态，它可以与任何新类实现该接口。但是，当代码使用一大堆的具体类时，等于是自找麻烦，因为一旦加入新的具体类，就必须要改变代码。在这里我们希望能够调用一个简单的方法，我传递一个参数过去，就可以返回给我一个相应的具体对象，这个时候我们就可以使用简单工厂模式。

  1.1 基本定义

　　简单工厂模式又称之为静态工厂方法，属于创建型模式。在简单工厂模式中，可以根据传递的参数不同，返回不同类的实例。简单工厂模式定义了一个类，这个类专门用于创建其他类的实例，这些被创建的类都有一个共同的父类。

简单工厂模式其实不是一个设计模式，反而比较像是一种编程习惯。但由于经常被使用，有些开发人员的确是把这个编程习惯误认为是“工厂模式”。

模式场景：在一个披萨店中，要根据不同客户的口味，生产不同的披萨，如素食披萨、希腊披萨等披萨。

 

 

 

1.2 简单工厂模式实现

代码实现：

Pizza制造工厂：SimplyPizzaFactory.java

/**
 * 专门用于创建披萨的工厂类
 */
public class SimplePizzaFactory {
    public Pizza createPizza(String type){
        Pizza pizza = null;
        
        if(type.equals("cheese")){
            pizza = new CheesePizza();
        }
        else if(type.equals("clam")){
            pizza = new ClamPizza();
        }
        else if(type.equals("pepperoni")){
            pizza = new PepperoniPizza();
        }
        else if(type.equals("veggie")){
            pizza = new VeggiePizze();
        }
        
        return pizza;
    }
}

 

抽象披萨：Pizza.java

/**
 * 抽象pizza类
 */
public abstract class Pizza {
    public abstract void prepare();
    
    public abstract void bake();
    
    public abstract void cut();
    
    public abstract void box();
}

 

 具体披萨：CheesePizza.java：

public class CheesePizza extends Pizza{

    @Override
    public void bake() {
        System.out.println("bake CheesePizza ...");
    }

    @Override
    public void box() {
        System.out.println("box CheesePizza ...");
    }

    @Override
    public void cut() {
        System.out.println("cut CheesePizza ...");
    }

    @Override
    public void prepare() {
        System.out.println("prepare CheesePizza ...");
    }

}

 

 PizzaStore.java

public class PizzaStore {
    SimplePizzaFactory factory;      //SimplePizzaFactory的引用
    public PizzaStore(SimplePizzaFactory factory){
        this.factory = factory;
    }
    
    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza = factory.createPizza(type);       //使用工厂对象的创建方法，而不是直接new。这里不再使用具体实例化
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
}

 

1.3 优缺点和使用场景

优点

1、简单工厂模式实现了对责任的分割，提供了专门的工厂类用于创建对象。

 2、客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

3、通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

 

缺点

1、由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

2、使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。

3、系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

4、简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

 

使用场景

1、  工厂类负责创建的对象比较少。

2、  客户端只知道传入工厂类的参数，对于如何创建对象不关心。

 

第2部分 工厂模式

2.1 问题引入

　　在第1部分中通过披萨的实例介绍了简单工厂模式。在披萨实例中，如果我想根据地域的不同生产出不同口味的披萨，如纽约口味披萨，芝加哥口味披萨。如果利用简单工厂模式，我们需要两个不同的工厂，NYPizzaFactory、ChicagoPizzaFactory。在该地域中有很多的披萨店，他们并不想依照总店的制作流程来生成披萨，而是希望采用他们自己的制作流程。这个时候如果还使用简单工厂模式，因为简单工厂模式是将披萨的制作流程完全承包了。那么怎么办？

 　　我们可以这样解决：将披萨的制作方法交给各个披萨店完成，但是他们只能提供制作完成的披萨，披萨的订单处理仍然要交给披萨工厂去做。也就是说，我们将createPizza()方法放回到PizzaStore中，其他的部分还是保持不变。

 

2.2 基本定义

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让实例化推迟到子类。

所谓的“决定”，并不是指模式允许子类本身在运行时做决定，而是指在编写创建者类时，不需要知道实际创建的产品时哪一个。选择了使用哪个子类，自然就决定了实际创建的产品是什么。

2.3 工厂方法模式实现

抽象产品类：Pizza.java

 

package firsthead.factorypattern;

import java.util.ArrayList;

/**
 * 
 * @ClassName: Pizza
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午3:45:05
 */
public class Pizza {
    //名称  
    String name;
    //面团  
    String dough;
    //酱料 
    String sauce;    
    //佐料 
    ArrayList toppings = new ArrayList();

    void prepare() {
        System.out.println("Preparing " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding toppings: ");
        for (int i = 0; i < toppings.size(); i++) {
            System.out.println("   " + toppings.get(i));
        }
    }
    public String getName() {
        return name;
    }
    
    public void bake(){
        System.out.println("Bake for 25 minutes at 350");    
    }
    
    public void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    public void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }
    
    public String toString(){
        StringBuffer disPlay = new StringBuffer();
        disPlay.append("---- " + name + " ----\n");
        disPlay.append(dough + "\n");
        disPlay.append(sauce + "\n");
        for (int i = 0; i < toppings.size(); i++) {
            disPlay.append((String )toppings.get(i) + "\n");
        }
        return disPlay.toString();
    }

}

 

具体产品类：NYStyleCheesePizza.java

public class NYStyleCheesePizza extends Pizza{
    
    public NYStyleCheesePizza(){
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
        toppings.add("Grated Reggiano Cheese");
    }
}

 

具体产品类：ChicagoStyleCheesePizza .java

public class ChicagoStyleCheesePizza extends Pizza{
    public ChicagoStyleCheesePizza() { 
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";
 
        toppings.add("Shredded Mozzarella Cheese");
    }
 
    public void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

 

 

抽象工厂：披萨总店。PizzaStore.java

package firsthead.factorypattern;

/**
 * 披萨商店
 * @ClassName: PizzaStore
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午2:49:46
 */
public abstract class PizzaStore {

    //订购Pizza
    public Pizza orderPizza(String type){
        Pizza pizza;
        
        //pizza = factory.createPizza(type);
        //从工厂对象中移回
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
    
    //实例化披萨的责任被移到一个“方法”中，此方法就如同是一个工厂
    //创建pizza的方法交给子类去实现 
    protected abstract Pizza createPizza(String type);
}

 

具体工厂。披萨分店。NYPizzaStore.java

package firsthead.factorypattern;

/**
 * 加盟店——纽约披萨商店
 * @ClassName: NYPizzaStore
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午4:12:03
 */
public class NYPizzaStore extends PizzaStore{

    /**
     * 
     * @Description: 
     * @param item
     * @return
     * @author xingle
     * @data 2014-8-22 下午4:16:21
     */
    @Override
    protected
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new NYStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else return null;
    }
    

}

 

具体工厂。披萨分店。ChicagoPizzaStore.java

package firsthead.factorypattern;

/**
 * 加盟店——芝加哥披萨商店
 * @ClassName: ChicagoPizzaStore
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午4:18:47
 */
public class ChicagoPizzaStore extends PizzaStore{

    /**
     * 
     * @Description: TODO
     * @param item
     * @return
     * @author xingle
     * @data 2014-8-22 下午4:19:35
     */
    @Override
    protected
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new ChicagoStyleCheesePizza();
    } else if (item.equals("veggie")) {
            return new ChicagoStyleVeggiePizza();
    } else if (item.equals("clam")) {
            return new ChicagoStyleClamPizza();
    } else if (item.equals("pepperoni")) {
            return new ChicagoStylePepperoniPizza();
    } else return null;
    }

}

 

最后测试程序，PizzaTestDrive.java

package firsthead.factorypattern;

/**
 * 测试程序
 * @ClassName: PizzaTestDrive
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午4:38:46
 */
public class PizzaTestDrive {
     public static void main(String[] args){
         PizzaStore nyStore = new NYPizzaStore();
         PizzaStore chicageStore = new ChicagoPizzaStore();
         
         System.out.println("---------Ethan 需要的纽约风味的披萨---------");  
         Pizza  pizza = nyStore.orderPizza("cheese");
         System.out.println("Ethan ordered a "+pizza.getName()+"\n");
         
         System.out.println("---------Joel 需要的芝加哥的深盘披萨---------");  
         pizza = chicageStore.orderPizza("cheese");
         System.out.println("Joel ordered a "+pizza.getName());
     }
}

 

执行结果：

 

 2.4 工厂方法模式优缺点和应用场景

优点

1、  在工厂方法中，用户只需要知道所要产品的具体工厂，无须关系具体的创建过程，甚至不需要具体产品类的类名。

2、  在系统增加新的产品时，我们只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，很好地符合了“开闭原则”。

 缺点

1、  每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

适用场景

1、一个类不知道它所需要的对象的类。在工厂方法模式中，我们不需要具体产品的类名，我们只需要知道创建它的具体工厂即可。

2、一个类通过其子类来指定创建那个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

3、将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。

 

第3部分 抽象工厂模式

3.1 问题引入

 　　在工厂方法模式中，我们使用一个工厂创建一个产品，也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。

3.2 基本定义

抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。

抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。

3.3 抽象工厂模式实现

　　依然是披萨店。为了要保证每家加盟店都能够生产高质量的披萨，防止使用劣质的原料，我们打算建造一家生产原料的工厂，并将原料运送到各家加盟店。但是加盟店都位于不同的区域，比如纽约、芝加哥。纽约使用一组原料，芝加哥使用另一种原料。在这里我们可以这样理解，这些不同的区域组成了原料家族，每个区域实现了一个完整的原料家族。

首先创建一个原料工厂。该工厂为抽象工厂，负责创建所有的原料。

PizzaIngredientFactory.java

package firsthead.factorypattern;

/**
 * 
 * @ClassName: PizzaIngredientFactory
 * TODO
 * @author Xingle
 * @date 2014-8-26 上午10:56:43
 */
public interface PizzaIngredientFactory {
    //在接口中，每个原料都有一个对应的方法创建该原料 
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
}

 

原料工厂创建完成之后，需要创建具体的原料工厂。该具体工厂只需要继承PizzaIngredientFactory，然后实现里面的方法即可。

 纽约原料工厂：NYPizzaIngredientFactory.java。

package firsthead.factorypattern;

/**
 * 具体原料工厂——纽约原料工厂
 * @ClassName: NYPizzaIngredientFactory
 * TODO
 * @author Xingle
 * @date 2014-8-26 上午10:58:17
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory{

    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce(); 
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Clams createClam() {
        return new FreshClams();
    }

}

 

具体原料：

public class ThinCrustDough implements Dough {
    public String toString() {
        return "Thin Crust Dough";
    }
}

public class MarinaraSauce implements Sauce {
    public String toString() {
        return "Marinara Sauce";
    }
}

public class ReggianoCheese implements Cheese {
    public String toString() {
        return "Reggiano Cheese";
    }
}

public class Garlic implements Veggies {
    public String toString() {
        return "Garlic";
    }
}

public class Onion implements Veggies {
    public String toString() {
        return "Onion";
    }
}

public class Mushroom implements Veggies {
    public String toString() {
        return "Mushrooms";
    }
}

public class RedPepper implements Veggies {
    public String toString() {
        return "Red Pepper";
    }
}

public class SlicedPepperoni implements Pepperoni {
    public String toString() {
        return "Sliced Pepperoni";
    }
}

public class FreshClams implements Clams {
    public String toString() {
        return "Fresh Clams from Long Island Sound";
    }
}

public interface Veggies {
    public String toString();
}

其他类似

 

重新返回到披萨。在这个披萨类里面，我们需要使用原料，其他方法保持不变，将prepare()方法声明为抽象，在这个方法中，我们需要收集披萨所需要的原料。

Pizza.java

package firsthead.factorypattern;

import java.util.ArrayList;

/**
 * 
 * @ClassName: Pizza
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午3:45:05
 */
public abstract class Pizza {
    /*每个披萨都持有一组在准备时会用到的原料 */
    String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;
    //佐料 
    ArrayList toppings = new ArrayList();

    
    /**
     * prepare()方法声明为抽象方法。在这个方法中，我们需要收集披萨所需要的原料，而这些原料都是来自原料工厂 
     */
    abstract void prepare();
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public void bake(){
        System.out.println("Bake for 25 minutes at 350");    
    }
    
    public void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    public void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }
    
    public String toString(){
        StringBuffer disPlay = new StringBuffer();
        disPlay.append("---- " + name + " ----\n");
        disPlay.append(dough + "\n");
        disPlay.append(sauce + "\n");
        for (int i = 0; i < toppings.size(); i++) {
            disPlay.append((String )toppings.get(i) + "\n");
        }
        return disPlay.toString();
    }

}

 

CheesePizza.java

package firsthead.factorypattern;

/**
 * 
 * @ClassName: CheesePizza
 * TODO
 * @author Xingle
 * @date 2014-8-26 上午11:19:04
 */
public class CheesePizza extends Pizza{
    
    PizzaIngredientFactory ingredientFactory;
    
    public CheesePizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory = ingredientFactory;
        prepare();  
    }

    /**
     * 
     * @Description: 
     * @author xingle
     * @data 2014-8-26 上午11:27:17
     */
    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }

    

}

 

做完披萨后，需要关注披萨店了。

在披萨店中，我们依然需要关注原料，当地的披萨店需要和本地的原料工厂关联起来。

 PizzaStore.java

package firsthead.factorypattern;

/**
 * 披萨商店
 * @ClassName: PizzaStore
 * TODO
 * @author Xingle
 * @date 2014-8-22 下午2:49:46
 */
public abstract class PizzaStore {

    //订购Pizza
    public Pizza orderPizza(String type){
        Pizza pizza;

        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
    
    
    /**
     * 创建pizza的方法交给子类去实现 
     */
    abstract Pizza createPizza(String type);
}

 

纽约的披萨店：NYPizzaStore.java

package firsthead.factorypattern;

/**
 * 纽约的披萨店：
 * @ClassName: NYPizzaStore
 * TODO
 * @author Xingle
 * @date 2014-8-26 上午11:39:06
 */
public class NYPizzaStore extends PizzaStore{

    /**
     * 
     * @Description: 
     * @param type
     * @return
     * @author xingle
     * @data 2014-8-26 上午11:39:23
     */
    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        //使用纽约的原料工厂
        PizzaIngredientFactory ingredientFactory = 
            new NYPizzaIngredientFactory();
 
        if (item.equals("cheese")) {
  
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
  
        } else if (item.equals("veggie")) {
 
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
 
        } else if (item.equals("clam")) {
 
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
 
        } else if (item.equals("pepperoni")) {

            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("New York Style Pepperoni Pizza");
 
        } 
        return pizza;
    }

}

 

最后，测试程序

package firsthead.factorypattern;

/**
 * 
 * @ClassName: PizzaTestDrive
 * TODO
 * @author Xingle
 * @date 2014-8-26 上午11:37:20
 */
public class PizzaTestDrive {
    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        
        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza + "\n"); 
        
        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza + "\n");
         
        pizza = nyStore.orderPizza("pepperoni");
        System.out.println("Ethan ordered a " + pizza + "\n");
         
        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza + "\n");
 
        
    }

}

 

执行结果：

Preparing null
Preparing New York Style Cheese Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Cheese Pizza ----
Thin Crust Dough
Marinara Sauce


Preparing null
Preparing New York Style Clam Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Clam Pizza ----
Thin Crust Dough
Marinara Sauce


Preparing null
Preparing New York Style Pepperoni Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Pepperoni Pizza ----
Thin Crust Dough
Marinara Sauce


Preparing null
Preparing New York Style Veggie Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Veggie Pizza ----
Thin Crust Dough
Marinara Sauce