一、前期回顾

上一篇《》详细介绍了单例模式，介绍了单例模式的使用场景，优缺点，同时也写了两种常见的单例模式写法，懒汉式单例模式和饿汉氏单例模式，当然，单例模式的写法还有很多，比如，枚举单例模式，静态内部类单例模式等。有兴趣的可以自行查找资料。本篇开始介绍单例模式的第二篇，工厂方法模式，以及工厂模式的升级版，抽象工厂模式。

二、工厂方法模式的定义与实践

定义：Define an interface for creating an object,but let subclasses decide which class to instantiation.Factory Mehod lets a class defer instantiation to subclasses.翻译过来就是，定义一个用于创建对象的接口，让其子类决定实例化哪个类。工厂方法让一个类的实例化延迟到其子类。

上面的定义说明好像很绕口，如果不理解没关系，我们用个例子来说明这个定义：

//定义产品接口public interface Iproduct {    public void doSomething();}//产品实现类public class ProductA implements Iproduct {    @Override    public void doSomething() {        System.out.println("我是产品A，我可以搞事情");    }}//定义工厂类接口public interface IFactory {    //创建产品工厂方法    < T extends Iproduct> T creatProduct(Class
    
      clz);}//工厂方法实现类public class ProductFactory implements IFactory {    @Override    public 
     
       T creatProduct(Class
      
        clz) {        Iproduct product=null;        try {            product= clz.newInstance();        } catch (InstantiationException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }        return (T) product;    }}//场景类public class Client {    public static void main(String[] args) {        IFactory factory=new ProductFactory();        Iproduct product= factory.creatProduct(ProductA.class);        product.doSomething();    }}复制代码
      
     
    

上述例子，实现了一个简单的工厂方法模式，定义了一个工厂接口类，然后具体的工厂方法实现了创建对象的逻辑。看到这里，有人肯定会问，这里要new一个工厂类的实例，和我new一个具体的对象有什么区别呢？反正都要自己new，干嘛要搞一个工厂类这么绕呢？对，没错。这里是要new一个工厂类，但是上面的例子创建产品的对象是比较简单，所以感觉不出来，如果ProductA的实例创建是一个非常复杂的过程，那么这个时候我通过工厂方法模式创建对象的实例就很方便了。

肯定还有人问，我觉得上面这个方式还有点啰嗦，有没有更简便的方式实现工厂模式呢？答案是，有。我们接下来看看简单工厂模式。简单工厂方法模式就是上述工厂方法模式的简单版本。我们只要把上述工厂类的接口去掉，然后把工厂实现类改为静态类就可以实现简单工厂方法模式了。代码是这样的：

//这里只去掉了接口，改为静态方法public class ProductFactory  {    public static 
    
      T creatProduct(Class
     
       clz) {        Iproduct product=null;        try {            product= clz.newInstance();        } catch (InstantiationException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }        return (T) product;    }}public class Client {    public static void main(String[] args) {        Iproduct product= ProductFactory.creatProduct(ProductA.class);        product.doSomething();    }}复制代码
     
    

这里就不用自己去new 工厂类啦，代码也简洁了很多。但是去掉了接口也就意味着后面的扩展是不友好的，所以违反了开闭原则。

三、抽象工厂模式的定义与实践

定义：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.翻译： 提供一个创建相关或者相互依赖的对象的接口，并且无需指定他们的具体实现类。

这里理解可能有点困难，为了便于理解，我们先引入两个概念。

产品等级结构： 产品等级结构即产品的继承结构，如一个抽象类是汽车，其子类就是各个品牌的汽车，比如奔驰，宝马汽车。汽车和奔驰就构成了一个产品等级结构，抽象汽车是父类，而具体品牌的汽车是其子类。

产品族 ： 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如奔驰工厂生产的奔驰跑车，宝马公司生产的跑车，奔驰跑车位于奔驰产品等级结构中，宝马跑车位于宝马产品等级结构中。

所以，汽车和品牌是一个产品等级结构，而每个品牌下面有多个产品线，也就是说奔驰牌下面的汽车有多个产品族，比如跑车族，SUV族。奔驰跑车和宝马跑车是一个产品族，奔驰SUV和宝马SUV是一个产品族。所以上面定义中“相关或者相互依赖的对象”就是场景中包含，同一个等级结构中有不同的产品族。 ，我们来用一个实际场景来说明下。

假设，我需要一个汽车工厂，汽车可以生产跑车和SUV车型，那么这个时候用之前的工厂方法模式就不满足了，方法工厂模式只能满足生产一个产品，现在需要生产两个产品。所以我们在方法工厂模式的基础上改造下来满足这个场景。

//汽车接口public interface ICar {     void dirver();}//抽象汽车类public abstract class AbstractProduct implements ICar{    @Override    public void dirver() {        System.out.println("我是汽车，我可以开动");    }    /***     * 展示不同车的亮点*/    public abstract void showSpecial();}//宝马SUV实现类public class BmwSuv extends AbstractProduct {    @Override    public void showSpecial() {        System.out.println("我是宝马牌SUV，我的特点就是多功能用途");    }}//宝马跑车实现类public class BmwProductRoadster extends AbstractProduct {    @Override    public void showSpecial() {        System.out.println("我是宝马跑车，我的特点就是跑的快");    }}//奔驰SUVpublic class BenzSuv extends AbstractProduct {    @Override    public void showSpecial() {        System.out.println("我是奔驰牌SUV，我的特点就是多功能用途");    }}//奔驰跑车public class BenzProductRoadster extends AbstractProduct {    @Override    public void showSpecial() {        System.out.println("我是奔驰跑车，我的特点就是跑的快");    }}//抽象工厂类public abstract class AbstractFactory {    //创建跑车    public abstract < T extends ICar> T createRoadster();    //创建SUV    public abstract < T extends ICar> T createSuv();}//奔驰汽车工厂类public class BenzFactory extends AbstractFactory {    @Override    public 
    
      T createRoadster() {        return (T) new BenzProductRoadster();    }    @Override    public 
     
       T createSuv() {        return (T) new BenzSuv();    }}//宝马汽车工厂类public class BmwFactory extends AbstractFactory {    @Override    public 
      
        T createRoadster() {        return (T) new BmwProductRoadster();    }    @Override    public 
       
         T createSuv() {        return (T) new BmwSuv();    }}//场景类public class Client {    public static void main(String[] args) {        AbstractFactory bmwFactory=new BmwFactory();        AbstractFactory benzFactory=new BenzFactory();        AbstractProduct bmwRoadster= bmwFactory.createRoadster();        AbstractProduct bmwSuv=bmwFactory.createSuv();        AbstractProduct benzRoadster=benzFactory.createRoadster();        AbstractProduct benzSuv=benzFactory.createSuv();        bmwRoadster.showSpecial();        bmwSuv.showSpecial();        benzRoadster.showSpecial();        benzSuv.showSpecial();    }}复制代码
       
      
     
    

细心的读者应该发现，我们的改造相对于工厂方法模式而言，只是抽象工厂模式新增了多一个创建方法。这也是抽象工厂模式和工厂方法模式最明显的区别，抽象工厂模式可以满足多类型，多业务的场景，比如汽车工厂可以生产多种类型汽车，就适用于抽象工厂模式。而普通工厂方法模式就是针对生产某一种对象而言比较适用。总结来说就是，抽象工厂模式适用于多产品族的情况，普通工厂方法模式适用于单产品族情况。

四、总结

上面介绍了工厂方法模式与抽象工厂模式的定义与实践，同时也衍生了一个简单工厂模式。我们先来总结下工厂模式的优点与缺点。

优点：

1.良好的封装性，代码结构清晰，不用关注具体对象的创建过程，符合迪米特法则。

2.良好的扩展性，我们扩展了产品，只要新建对应的工厂类，实现自己的实现逻辑即可。

缺点：

1.对于抽象工厂模式，产品族的扩展比较困难，需要修改顶部抽象工厂类，这会导致所有实现类都要修改，不符合开闭原则。

2.对于简单工厂模式，由于没有接口和抽象父类的约束，从而也会导致扩展只能修改代码，不符合开闭原则。

最后我们列一个表格来总结下工厂方法模式，简单工厂模式，抽象工厂模式的区别。

五、参考

《设计模式之禅》

六、推荐阅读

《》

《》

《》

《》

《》

《》

《》