一、白话

  假如我有三台笔记本，华硕，联想，苹果。 出外办公的时候，根据对接的公司的不同，于是想使用不同的笔记本，于是去苹果公司，我对秘书妹妹说：“帮我把苹果笔记本打开一下”，去华硕公司，说：“帮我把华硕笔记本打开一下”，去联想公司，说:“帮我把联想笔记本打开一下”。秘书妹妹表示我对她的不信任对我抗议道：“老板，你直接说打开电脑就行了，使用哪台笔记本我知道的”。

二、定义

  工厂模式：就是定义了一系列创建对象的接口，访问类不需要提供具体的类就可以得到相应的对象，并对得到的对象加以控制，如个数。

三、简单工厂模式

  简单工厂为最简单的一种工厂模式。共计三个角色：工厂、抽象产品、具体产品。

    代码展示：

/**
 * 抽象产品角色
 */
public interface INoteBook {
    /**
     * 开机
     */
    public void open();
}

/**
 * 具体产品
 */
public class Asus implements INoteBook {
    public void open(){
        System.out.println("华硕开机...");
    }
}
/**
 * 具体产品
 */
public class Lenovo implements INoteBook {
    public void open(){
        System.out.println("联想开机...");
    }
}
/**
 * 具体产品
 */
public class Mac implements INoteBook {
    public void open(){
        System.out.println("苹果开机...");
    }
}

/**
 * 工厂类角色
 */
public class NotebookFactory {
    public static INoteBook create(String note) {
        if("asus".equals(note)) {
            return new Asus();
        } else if ("lenovo".equals(note)) {
            return new Lenovo();
        } else if ("mac".equals(note)) {
            return new Mac();
        } else {
            throw new RuntimeException("没有此公司");
        }

    }
}

/**
 * 客户端执行
 */
public class FactoryApplication {

    public static void main(String[] args) {
        // 去往哪个公司
        INoteBook asus = NotebookFactory.create("asus");
        // 开机
        asus.open();
    }

}

   最后输出 “华硕开机...”。

  上面完成一套简单工厂模式的演示，我们只需要说开机，就可以完成相应的动作，而不用在意内部细节的不同。更符合设计要求，但是问题也是很明显，过于依赖工厂角色，每当有新的笔记本加入，则需要修改工厂代码，不符合开闭原则，同时，过多的笔记本也会导致工厂依赖过重，出现上帝类情况。针对更为复杂的情况，产品较多的情况，简单工厂就无法满足我们的要求，需要做进一步升级。例如工厂方法模式

四、工厂方法模式

  工厂方法模式也是比较简单，只是在简单工厂的基础上拆分掉具体工厂角色的创建功能，拆分成多个，各个产品有各自的具体工厂角色，增加抽象工厂角色。其实就是使用动态代替了if else的手段。

  白话：因为合作的公司越来越多，秘书携带的笔记本过多，于是跟秘书说，我给你加几个负责人，笔记本让他们带着，你负责管理他们就可以了。

/**
 * 抽象工厂角色
 */
public interface INoteBookFactory {
    public INoteBook creat();
}

/**
 * 华硕具体工厂角色
 */
public class AsusFactory implements INoteBookFactory {
    @Override
    public INoteBook creat() {
        return new Asus();
    }
}
/**
 * 联想具体工厂角色
 */
public class LenovoFactory implements INoteBookFactory {
    @Override
    public INoteBook creat() {
        return new Lenovo();
    }
}
/**
 * 苹果具体工厂角色
 */
public class MacFactory implements INoteBookFactory {
    @Override
    public INoteBook creat() {
        return new Mac();
    }
}

   以上就完成了一次工厂方法模式，利用了多态代替了if else。效果也很明显，工厂职责单独拆分掉。不会导致依赖过重，同时对于新增的产品，只需要继承抽象工厂，产生相应的产品即可。符合开闭原则。但是，也随之产生了问题，由于每个角色都有自己的单独的工厂，会导致过多的实现类，导致代码冗余，产生过多的类，这不是所期望看到的。针对更为复杂的场景，于是做升级，例如抽象工厂模式

五、抽象工厂模式

  个人理解，就是在工厂方法基础上有了产品族的一个概念。避免产生过多的实现类，对工厂角色增加相似的功能。

  白话：随着业务增多，不仅仅需要笔记本，还有手机。两者功能类似，把两者作为一个产品族的概念，各个负责人需要把自己负责的产品族都带上。为了更好的审美和劳逸结合，新增了一个秘书MM,之前的秘书依旧负责管理这些人，选择哪位负责人进行业务动作，而新来的秘书负责管理产品有哪些业务动作。

  代码演示

/**
 * 抽象产品族概念 数码
 */
public abstract class AbstractDigital {
    public abstract void open();
}
/**
 * 抽象产品角色
 */
public abstract class INoteBook extends AbstractDigital {
    public abstract void open();
}
/**
 * 抽象产品角色
 */
public abstract class IPhone extends AbstractDigital {
    public abstract void open();
}
/**
 * 具体产品角色
 */
public class AsusPhone extends IPhone {
    public void open(){
        System.out.println("华硕手机开机中...");
    }
}
/**
 * 具体产品
 */
public class Asus extends INoteBook {
    public void open(){
        System.out.println("华硕开机...");
    }
}

/**
 * 抽象工厂角色 数码
 */
public interface IDigitalFactoary {
    public INoteBook createNote();
    public IPhone createPhone();
}
/**
 * 华硕具体工厂角色
 */
public class AsusFactory implements IDigitalFactoary {
    @Override
    public INoteBook createNote() {
        return new Asus();
    }
    @Override
    public IPhone createPhone() {
        return new AsusPhone();
    }
}
/**
 * 联想具体工厂角色
 */
public class LenovoFactory implements IDigitalFactoary {
    @Override
    public INoteBook createNote() {
        return new Lenovo();
    }
    @Override
    public IPhone createPhone() {
        return new LenovoPhone();
    }
}

public static void main(String[] args) {
    // 去往哪个公司
    IDigitalFactoary asusFactory = new AsusFactory();
    AbstractDigital note = asusFactory.createNote();
    AbstractDigital phone = asusFactory.createPhone();
    // 开机
    note.open();
    phone.open();
}

  以上，就完成了一次抽象工厂模式的演示。文中是用品牌的方式作为了一个产品族，不一定合适，需要结合业务实际场景，选择最合理的封装，万物皆对象，只有合适的才是最好的。例如可以选择类似的电子产品作为一个产品族。同时抽象工厂模式是应对较为复杂的场景，需要足够多的产品和品牌，用来解决类似的场景，如果业务本身并不复杂，采用更简单的模式或许更好。

  最后，君共勉。