设计模式----创建型模式之工厂模式(FactoryPattern)

　　工厂模式主要分为三种简单工厂模式、工厂方法模式、抽象工厂模式三种。顾名思义，工厂主要是生产产品，作为顾客或者商家，我们不考虑工厂内部是怎么一个流程，我们要的是最终产品。将该种思路放在我们面向对象开发实战中，就能使我们代码达到解耦。

　　首先，在引出这三种关于工厂模式，我们介绍几组对象：

　　1、抽象产品。所谓抽象产品，是具体抽象的抽象形式。例如:披萨、原料、汽车等(注：披萨和原料引自head first设计模式一书)。

　　2、具体产品。抽象产品的具体化。蛤蜊披萨和素食披萨等就是抽象产品的具体化产品，面团、酱料和芝士等就是原料的具体化产品，但是会因为地域性差异，同一种产品是有所区别的。

　　3、工厂。客户使用工厂对象方法获取到具体产品。

• 简单工厂模式(Simple Factory Pattern)

　　UML结构图如下所示：

　　 

　　从UML结构图可以看出（注：简单工厂模式又称静态工厂模式）：

1. 工厂与抽象产品的关系是组合关系；
2. 工厂类通过createProduct()方法创建产品，该方法内部根据形参；
3. 作为Client，只需要通过实例化Factory调用creatProduct(){若该方法为非静态方法，若静态方法直接调用，不需要实例}获取相应的具体产品实例。

　　 简单工厂模式遵循着“封装变化”原则。客户后续需要更多种类的产品，只需要修改工厂类及新增具体产品类即可，从而产品的使用和产生的隔离。

　　简单实例：

public abstract class Product {

}

public class ProductA extends Product{
    public String toString() {
        return "I am Product A";
    }
}

public class ProductB extends Product{
    public String toString() {
        return "I am Product B";
    }
}

public class SimpleFactory {
    Product product;
    public Product createProduct(int param){
        switch (param) {
        case 1:
            product =new ProductA();
            break;
        case 2:
            product =new ProductB();
            break;
        default:
            break;
        }
        return product;
    }
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product proA = factory.createProduct(1);
        System.out.println(proA);
        Product proB = factory.createProduct(2);
        System.out.println(proB);
    }
       /**     输出：
     *   I am Product A
     *   I am Product B
     *
     */
}

• 工厂方法模式（Factory Method Pattern）

　　简单工厂模式自身存在缺点，主要实现的目的是把变化部分出去出来，便于我们修改。但是这样对于新增产品，我们就得就修改工厂类，这样一来就已经不遵循“开-闭”原则{对修改关闭，对扩展开放}。

　　因此，我们引入工厂方法模式：

　　　　定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

　　UML结构图如下所示：

　　

　　利用工厂方法模式生产产品A或产品B，代码如下所示：　

//所有具体工厂的抽象工厂
public abstract class Factory {
    public abstract Product createProduct();
}
//生产A的具体工厂
public class ProductFactoryA extends Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

//生产B的具体工厂
public class ProductFactoryB extends Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ProductFactoryA();
        Product proA = factory.createProduct();
        System.out.println(proA);
        Factory factory2 = new ProductFactoryB();
        Product proB = factory2.createProduct();
        System.out.println(proB);
        /**
         * 输出:
         * I am Product A
         * I am Product B
         */
    }
}

• 抽象工厂模式（Abstract Factory Pattern）

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

　　UML结构图如下图所示（参照于head first设计模式一书）：

　　抽象工厂方法其实就是工厂方法的一种升华：1、从客户的角度来看，只需要关注抽象工厂和抽象产品，不需要关注具体的产品和具体的工厂类实现。2、从抽象工厂的角度来看，不需要关注具体的工厂实现，也不需要关注生产产品，生产产品的都是派生类来实现。3、从具体工厂的角度来看，生产的产品有一定的共性，不需要关注具体产品的实现。。。这些都可以从类图里面看出来。通过类图，我们发现：工厂抽象和产品抽象是隔离的。

　　觉得《Head First 设计模式》书中的例子才是经典的，就不给出源码，想看的只能找度娘了。

• 总结

　　1、所谓工厂，都是用来封装对象的创建；

　　2、简单工厂实现将客户程序从具体类中解耦。但如果扩展产品，只能在工厂类里面修改，对于后期的维护以及扩展增加了困难；

　　3、工厂方法使用了继承，把对象创建委托给子类，子类实现工厂方法来创建对象；

　　。。。。

　　这两个月工作有点忙，顺便学习了原始的servlet，设计模式看得比较少。共勉