1.落笔缘由

由于看了《Head First Design Patterns》一书，查阅资料对各种模式有所理解，把网上的觉得比较容易理解的资料摘抄下来，并根据《Head First Design Patterns》的内容进行实践和理解，在此做下笔记。

2.工厂模式概念与分类

工厂模式属于创建型模式。
工厂模式可以分为三种：

1）简单工厂模式(Simple Factory)

简单工厂其实不是一种设计模式，反而更像一种编程习惯。

2）工厂方法模式(Factory Method)

定义了一个创建对象的接口，但由子类决定实例化的类是哪一个，工厂方法让类把实例化推迟到子类。（Head First Design Patterns这样定义的）

3）抽象工厂模式(Abstract Factory)

提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。（Head First Design Patterns这样定义的）

3.简单工厂模式

简单工厂模式类图

它由三种角色组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

抽象产品角色：

public interface Pizza {

    public void prepare();
    public void bake();
    public void cut();
    public void box();
}

具体产品角色：
产品一：起司披萨

public class CheezePizza implements Pizza {

    public CheezePizza() {
        System.out.println("起司Pizza");
    }

    public void bake() {
    }

    public void box() {
    }

    public void cut() {
    }

    public void prepare() {
    }
}

产品二：蔬菜披萨

public class VaggiesPizza implements Pizza {

    public VaggiesPizza() {
        System.out.println("Vaggle Pizza");
    }
    public void bake() {
    }

    public void box() {
    }

    public void cut() {
    }

    public void prepare() {
    }
}

工厂角色：

public class SimplePizzaFactory {

    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new CheezePizza();
        }else if (type == 2) {
            pizza = new VagglePizza();
        }
        return pizza;
    }
}

客户端

public class Test2 {

    public static void main(String[] args) {
        SimplePizzaFactory simplePizzaFactory = new SimplePizzaFactory();
        Pizza  pizza = simplePizzaFactory.createPizza(1);
    }
}

4.工厂方法模式

工厂方法模式类图

它由四种角色组成：
抽象工厂角色：这是工厂方法模式的核心。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

抽象产品角色:

public abstract class Pizza {

    String name;
    String dough;
    String sauce;
    ArrayList topping = new ArrayList();
    public  void prepare()
    {
        System.out.println("Prepareing "+name);
        System.out.println(dough+" Dough");
        System.out.println(sauce+" Sauce");
        System.out.println("Add topping:");
        for (int i = 0; i < topping.size(); i++) {
            System.out.println(topping.get(i)+" ");
        }
    }
    public  void bake()
    {
        System.out.println("Bake for 35 minutes at 350");
    }
    public  void cut()
    {
        System.out.println("Cutting the pizza into diagonal slices");
    }
    public  void box()
    {
        System.out.println("Place pizza in offical PizzaStore box");
    }
}

具体产品角色:
产品一：纽约风味起司披萨

public class NYStyleCheesePizza extends Pizza {

    public NYStyleCheesePizza() {
        System.out.println("纽约起司Pizza");
    }
}

产品二：芝加哥起司披萨

public class ChicagoStyleCheesePizza extends Pizza {

    public ChicagoStyleCheesePizza() {
        System.out.println("芝加哥起司Pizza");
    }
}

抽象工厂角色：

public abstract class PizzaStore {

    public Pizza orderPizza(int type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(int type);
}

具体工厂角色一：纽约披萨工厂

public class NYPizzaStore extends PizzaStore{

    public NYPizzaStore() {
        System.out.println("欢迎光临纽约Pizza店---------");
    }
    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new NYStyleCheesePizza();
        }
        return pizza;
    }
}

具体工厂角色二：芝加哥披萨工厂

    public ChicagoPizzaStore() {
        System.out.println("欢迎光临芝加哥Pizza店---------");
    }
    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new ChicagoStyleCheesePizza();
        }
        return pizza;
    }
}

客户端：

public class Test {
    public static void main(String[] args) {
        PizzaStore nyPizzaStore = new NYPizzaStore();
        nyPizzaStore.orderPizza(1);
        
        PizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
        chicagoPizzaStore.orderPizza(1);
    }
}

5.抽象工厂

抽象工厂类图

产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。
工厂方法模式与抽象工厂模式的区别：
工厂方法是提供一个抽象接口来创建“一个产品”。
抽象工厂是提供一个抽象接口来创建一个产品家族。

抽象工厂由四种角色组成：：
抽象工厂角色：是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

抽象产品角色：
抽象产品角色一：抽象起司

public interface Cheese {
}

起司具体产品一：Mozzaralla起司

public class MozzarallaCheese implements Cheese {
    public MozzarallaCheese() {
        System.out.println("MozzarallaCheese");
    }
}

起司具体产品二：Regglano起司

public class RegglanoCheese implements Cheese {

    public RegglanoCheese() {
        System.out.println("RegglanoCheese");
    }
}

抽象产品角色二：抽象蔬菜

public interface Veggie {
}

蔬菜具体产品一：茄子

public class EggPlant implements Veggie {

    public EggPlant() {
        System.out.println("EggPlant");
    }
}

蔬菜具体产品二：菠菜

public class Spinach implements Veggie {
    public Spinach() {
        System.out.println("Spinach");
    }
}

蔬菜具体产品三：红辣椒

public class RedPepper implements Veggie {
    public RedPepper() {
        System.out.println("RedPepper");
    }
}

蔬菜具体产品四：黑橄榄

public class BlackOlives implements Veggie {

    public BlackOlives() {
        System.out.println("BlackOlives");
    }
}

蔬菜具体产品五：大蒜

public class Garlic implements Veggie {

    public Garlic() {
        System.out.println("Garlic");
    }
}

抽象工厂角色：
抽象工厂角色：原材料工厂

public interface IngredientFactory {

    public  Clam createClams();
    public  Sauce createSauce();
    public  Cheese createCheese();
    public  Dough createDough();
    public Veggie[] createVeggies();
    public Pepperoni createPepperoni();
}

具体工厂角色一：纽约原料工厂

public class NYIngredientFactory implements IngredientFactory {

    public Cheese createCheese() {
        return new RegglanoCheese();
    }

    public Clam createClams() {
        return new FreshClams();
    }

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

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

    public Sauce createSauce() {
        return new ManinaraSauce();
    }

    public Veggie[] createVeggies() {
        Veggie[] veggies= {new Garlic(),new Onion(),new Mashroom(),new RedPepper()};
        return veggies;
    }
}

具体工厂角色二：芝加哥原料工厂

public class ChicagoIngredientFactory implements IngredientFactory {

    public Cheese createCheese() {
        return new MozzarallaCheese();
    }

    public Clam createClams() {
        return new FrozenClams();
    }

    public Dough createDough() {
        return new ThickCrustDough();
    }

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

    public Sauce createSauce() {
        return new PlumTomatoSauce();
    }

    public Veggie[] createVeggies() {
        Veggie[] veggies = {new BlackOlives(),new EggPlant(),new Garlic()};
        return veggies;
    }
}

例子类图

6.总结

1）所以的工厂都是用来封装对象的创建。
2）工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。

public abstract class PizzaStore {

    public Pizza orderPizza(int type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
//子类实现这工厂方法来创建对象
    abstract Pizza createPizza(int type);
}

3）抽象工厂使用对象组合，对象的创建被实现在工厂接口所暴露的方法中。
4）所以工厂模式都通过减少客户端和具体类之间的依赖来实现解耦。
5）工厂方法允许类将实例化延迟到子类进行。
6）抽象工厂创建相关的对象家族，而不需要依赖他们的具体类。
7）依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象。

7.源码地址

http://download.csdn.net/detail/lgywsdy/9748030

8.参考文章

http://www.runoob.com/design-pattern/abstract-factory-pattern.html
http://www.cnblogs.com/zhangchenliang/p/3700820.html
http://download.csdn.net/detail/lgywsdy/9748113