Java之设计模式（工厂模式）

最近有点迷茫了，感觉自己的技术卡在了一个地方，没法再进一步了，也就是所谓的遇到瓶颈了吧，所以也变得烦躁，什么都不想干了，静心停止了几天，好好想了下自己的问题，也做了个新的规划，现在要抓紧时间提高自己的技术了，现在工作两年了，对自己的技术打分，不及格！对自己很是失望，所以做了个学习计划，希望自己能在技术这条路上能越走越远，而不是止步不前。

不好意思，废话说了一堆。今天说说工厂模式吧，以前就想写下的，但是懒啊，也怪不得自己对自己技术失望了，哎。

工厂模式呢，简单的说工厂模式不是一个模式，而是一系列模式，它相当于是一个统称吧，工厂模式包括：工厂方法模式、简单工厂模式、抽象工厂模式。不过这个也不是绝对的吧，因为有些把简单工厂模式规划到工厂方法模式里面了，因为它是工厂方法模式的一个弱化版本，简单工厂模式也有的称为静态工厂模式。

先举个例子来说明三者的大致区别的，具体看后面的具体分析：
假设我现在需要生产汽车（妈的，怎么都是汽车，好多人讲设计模式都是用汽车！我也没法啊~情不自禁啊，谁让汽车是大家都想要的啊，泡妹和装逼的神器啊，咳，正事，主要是汽车的分类好理解些，所以都用汽车）
1.假设生产汽车，我们只生产兰博基尼，所以我们只需要一个工厂就行了，这就是简单工厂模式；
2.现在需要生产两种汽车：兰博基尼和法拉利，假设两种汽车生产所需零件都一样，那么此时就只需要两个工厂，也就是多工厂方法模式，跟简单工厂的区别就是简单工厂只有一个工厂，所以也有说法把简单工厂划为工厂方法模式，因为它是一个工厂方法模式的弱化版，单工厂版；
3.那么问题来了，如果兰博基尼和法拉利生产所需零件不一样，轮胎啊，引擎啊之类不一样，那么此时我们就需要多分出一层了（零件层），因为之前兰博基尼和法拉利生产零件一样，所以不需要分直接一套生产就行，那么现在我们需要生产不同的零件，然后不同的零件合成不同的汽车，不同的汽车又要不同的工厂，这就是抽象工厂模式。

上述工厂模式需要三个模块：
1.抽象产品类；（抽象汽车）
2.具体产品类；（具体汽车类：兰博基尼和法拉利）
3.抽象工厂类；（抽象工厂）
4.具体工厂类；（具体工厂类：兰博基尼工厂和法拉利工厂）

首先来举例说明工厂方法模式（包括简单工厂模式）：
抽象产品类：

package FactoryPattern;/** * 抽象产品类 */public abstract class Product {    //抽象方法，生产零件组成汽车    public abstract void createProduct();}

具体产品类：

/** * 产品A，兰博基尼 */public class ProductA extends Product{    @Override    public void createProduct() {        // TODO Auto-generated method stub        System.out.println("生产组装成兰博基尼");    }/** * 产品B，法拉利 */public class ProductB extends Product{    @Override    public void createProduct() {        // TODO Auto-generated method stub        System.out.println("生产组装成法拉利");    }}

抽象工厂类：

/** *抽象工厂类 */public abstract class Factory {    public abstract Product createProduct();}

具体工厂类：

/** * 工厂类A，具体工厂，生产兰博基尼的工厂 */public class FactoryA extends Factory{    @Override    public Product createProduct() {        // TODO Auto-generated method stub        return new ProductA();  //生产兰博基尼    }}/** * 工厂类B，具体工厂，生产法拉利的工厂 */public class FactoryB extends Factory{    @Override    public Product createProduct() {        // TODO Auto-generated method stub        return new ProductB();  //生产法拉利    }}

生产汽车：

public class CreateProduct {    public static void main(String[] args){        //构造工厂对象生产汽车        Factory facA = new FactoryA();        facA.createProduct();        Factory facB = new FactoryB();        facB.createProduct();    }}

上述我们构造了两种工厂生产两种汽车，这就是多工厂方法模式，可以看到我们具体化了两种工厂。如果觉得多个工厂写起来麻烦，那么可以用反射来获取类来获取对应的工厂，如下（更改抽象工厂类和具体工厂类）：

/** *抽象工厂类 */public abstract class Factory {    public abstract <T extends Product>T createProduct(Class<T> cl);}//具体工厂类，通过传入类型进行创建public class MyFactory extends Factory{    @Override    public <T extends Product>T createProduct(Class<T> cl) {        // TODO Auto-generated method stub        Product p = null;        try {            p = (Product) Class.forName(cl.getName()).newInstance();        } catch (InstantiationException | IllegalAccessException| ClassNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        return (T)p;    }}//生产汽车public class CreateProduct {    public static void main(String[] args){        //构造工厂对象生产汽车        Factory fac = new MyFactory();        Product proA =fac.createProduct(ProductA.class);        Product proB =fac.createProduct(ProductB.class);    }}

上述都是两个工厂生产两种汽车，假设我们只需要一个工厂，生产一种汽车，那么我们就可以简化下了（不需要抽象工厂类，直接写工厂类生产产品）：

/** * 省掉抽象工厂类，因为我们只需要一个工厂，写抽象工厂类是因为工厂会有多个而且不同，既然只有一个工厂就可以省略 */public class Factory {    public static Product createProduct(){        return new ProductA();        //return new ProductB();    }}

像上述这种方式只有一个工厂，省略了抽象工厂，这种就是所谓的简单工厂模式。

那些复杂的抽象工厂方法模式又是怎样的呢，之前的是因为兰博基尼和法拉利零件啥都一样，所以只需要一个抽象产品类就行了，那么假设兰博基尼和法拉利所用零件不一样咋办，那就需要用抽象工厂模式了。所以我们可以理解为：
工厂方法模式：单抽象产品；
抽象工厂方法模式：多抽象产品；
示例（假设兰博基尼需要普通轮胎+高级引擎，而法拉利需要高级轮胎+普通引擎）：
抽象产品类：

//抽象产品类A，轮胎public abstract interface ProductA {    void createA();}//抽象产品类B，引擎public abstract interface ProductB {    void createB();}

具体产品类：

//具体产品类，普通轮胎public class ProAImpOne implements ProductA{    @Override    public void createA() {        // TODO Auto-generated method stub    }}//具体产品类，高级轮胎public class ProAImpTwo implements ProductA{    @Override    public void createA() {        // TODO Auto-generated method stub    }}//具体产品类，普通引擎public class ProBImpOne implements ProductB{    @Override    public void createB() {        // TODO Auto-generated method stub    }}//具体产品类，高级引擎public class ProBImpTwo implements ProductB{    @Override    public void createB() {        // TODO Auto-generated method stub    }}

抽象工厂类：

//抽象工厂类，里面方法是制造用的零件：轮胎和引擎public abstract interface Factory {    public abstract ProductA createA();    public abstract ProductB createB();}

具体工厂类：

//具体工厂类，法拉利public class FacFL implements Factory{    @Override    public ProductA createA() {  //高级轮胎        // TODO Auto-generated method stub        return null;    }    @Override    public ProductB createB() {  //普通引擎        // TODO Auto-generated method stub        return null;    }}//具体工厂类，兰博基尼public class FacLB implements Factory{    @Override    public ProductA createA() {  //普通轮胎        // TODO Auto-generated method stub        return new ProAImpOne();    }    @Override    public ProductB createB() {  //高级引擎        // TODO Auto-generated method stub        return new ProBImpTwo();    }}

如上所示：抽象产品类有多个，其他用法跟工厂方法模式类似，仅仅区别是在抽象产品不是单一的。可能我说的大家看得不是很明白，具体还得看例子，多看几遍就能明白其中的区别了，本人水平有限，不当之处还请指教哈~