工厂模式&抽象工厂——HeadFirst设计模式学习笔记

当使用new实例化一个类时，使用的是实现，而不是接口，代码捆绑着具体类会导致代码更脆弱缺乏弹性，使用松耦合的OO模式可以得到解脱。

工厂：封装对象的创建，处理创建对象的细节

静态工厂：利用静态方法定义一个简单的工厂。优点：不需要创建工厂类的实例化。缺点：不能通过继承改变创建方法行为。

简单工厂：简单工厂并不是一种设计模式，因为只是简单的把创建对象的代码封装起来

工厂模式：在父类定义了一个创建对象的接口，通过让子类决定创建的对象是什么，来达到让对象创建的过程封装的目的。工厂方法让类把实例化推迟到子类

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

特点：

• 工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样客户程序中超类的代码就和子类对象的创建部分解耦了
• 简单工厂vs工厂模式：简单工厂把全部的事情在一个地方做完了，而工厂模式是一个创建框架，让子类决定如何实现
• 抽象工厂vs工厂模式
  • 抽象工厂的方法经常以工厂方法的方式实现，抽象工厂的任务是定义一个负责创建一组产品的接口
  • 工厂方法使用继承，抽象工厂使用组合
  • 工厂方法只是用来创建一种产品，而抽象工厂创建的是一个产品家族
  • 使用工厂模式意味着需要扩展一个类并覆盖它的工厂方法。抽象工厂提供了一个创建产品家族的抽象类型，类型的子类定义了产品生产的方式

设计原则：

• 依赖倒置原则：要依赖抽象，不要依赖具体类。高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。（http://baike.baidu.com/link?url=mYRSYyXnTF-kbBdpEpLn53DrmxWb2QJBIIbxS4PA5IkqKJQolObBS8fzAXU81mOX962UcGuwwY6UOlAUavEX1WFQdJY7Xg96ezG7vj-Ss_y_8R_fCiSmSGN-DMM6XSroAmE6sKIFiSSBXJIOBl7cca）
• 变量不要持有具体类的引用
• 不要让类派生至具体类
• 不要覆盖基类中实现的方法

 类图及代码：

1、简单工厂

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;

        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

2、工厂模式

public abstract class PizzaStore {
 
    //这里定义一个工厂方法
    abstract Pizza createPizza(String item);
 
    public Pizza orderPizza(String type) {
    
        Pizza pizza = createPizza(type);
        
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
}

public class ChicagoPizzaStore extends PizzaStore {

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

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.getName() + "
");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza.getName() + "
");
    }
}

3、抽象工厂

先来定义一个接口PizzaIngredientFactory，他定义了一系列的创建Pizza材料的方法

public interface PizzaIngredientFactory {
 
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
 
}

子类

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
 
    public Dough createDough() {
        return new ThinCrustDough();
    }
 
    public Sauce createSauce() {
        return new MarinaraSauce();
    }
 
    public Cheese createCheese() {
        return new ReggianoCheese();
    }
 
    public Veggies[] createVeggies() {
        Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }
 
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

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

Pizza类

public class CheesePizza extends Pizza {
    //这里组合了一个PizzaIngredientFactory对象的引用，用于提供不同的原料
    PizzaIngredientFactory ingredientFactory;
 
    /**
     * 通过传入一个PizzaIngredientFactory原料工厂，我们可以在制作Pizza的时候动态的产生所需要的原料
     * @param ingredientFactory
     */
    
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
 
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

Pizza商店

public class NYPizzaStore extends PizzaStore {
 
    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;
    }
}