目录

1. 工厂模式

2. 为什么使用工厂模式

3. 应用实例

工厂模式

工厂模式：是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品

这里所提到的依赖注入，对于依赖的创建思想又引出一个概念：依赖倒置即为高层组件不再依赖底层组件，而底层组件也不再依赖高层组件，而是出现一个工厂类，高底层组建依赖于这个工厂类。下面针对具体的例子来进行讲解。

为什么使用工厂模式

工厂，生产物品的地方。工厂模式就是用来创建对象，生产对象的。一般，我们会通过new来进行对象的创建，一旦通过new，那么就一定会有具体的实例出现，也就会使得该对象和当前类出现紧耦合，产生依赖，使得我们代码的可扩展性和灵活性都变低。继续我们上篇文章中工厂生产机器的例子。

//机器装配的基类
public abstract class Machine{
//机器装配的流程，final不可被复写，保证方装配算法不被破坏
    final void produce(){
        createFrame();
        addHead();
        addBody();
        if(ifDressup())
            dressUp();
    }
//创建框架
    public abstract void createFrame();
//添加一个机器头
    public abstract void addHead();
//添加一个机器的身子
    public abstract void addBody();
//为机器进行装扮
    public abstract void dressUp();
//判断是否为该机器进行装扮
    public boolean ifDressup(){
        return true;
    }

}
//继承自基类的一个子类
public class InflatableDoll extends Machine{
    public void createFrame(){
        System.out.println("This is a Frame");
    }

    public void addBody(){
        System.out.println("This is a body");
    }

    public void dressUp(){
        System.out.println("This is a beautiful cloth");
    }

}

这是我们通过模板方法创建来创建我们机器的一个例子，那么现在我们有了一个新的需求，我们要对这些所有的机器在出售的时候要进行一个包装，根据客户点的类型，然后对其进行相应的包装之后，然后才可以出售。不同机器的包装流程大致相似的，所以我们可以这样来写我们的前台销售部门。

public class Store{

    public void order(String type){
         Machine machine;
        if(type=="inflatedoll"){
            machine = new InflatableDoll();
        }else if(type==""){
            ....
        }
        machine.produce();
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }

}
public class InflatableDoll extends Machine{

    public void firstPack(){
        System.out.prinltn("Add first pack to protect");
    }

    public void secondPack(){
        System.out.prinltn("Add second pack to protect");
    }

    public void thirdPack(){
        System.out.prinltn("Add third pack to protect");
    }

    public void fourthPack(){
        System.out.prinltn("Add fourth pack to protect");
    }
}

但是问题来了，当我们的机器种类不断增多，对于机器类型的判断，然后创建会使得我们的代码变得很繁琐，而且灵活性很差，按照设计模式的原则，封装变化的，我们将对与机器类型的判断和机器的创建封装起来，我们该这个封装起来的类起了个名字叫做工厂类，因为这个工厂类是可以用来产生新的对象的。封装代码如下。

public class MachineFactory{
    public Machine create(String type){
        Machine machine;
        if(type=="inflatabledoll"){
            machine = new InflatableDoll();
        }else if(){
            do something;
        }
        machine.produce();
        return machine;
    }
}

通过这个工厂类，我们的商店出售类就可以改变了,和具体的机器实例实现解耦和。

public class Store{

    Store(){
        MachineFactory factory = new MachineFactory();
    }

    public void order(String type){
         Machine machine= factory.create(type);
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }
}

顿时就感觉代码简洁了好多，而且条理也变得很清晰了。
通过例子，再去对我们之前的概念去理解，就会变得清晰很多，抽象工厂，具体工厂，抽象产品，具体产品。依赖注入，依赖倒置。首先对于抽象工厂和具体的工厂的理解，因为我们不同的产品可能在其生产上还是存在一些差异，所以通过一个抽象工厂类作为基类，然后针对不同的地方分别建立不同的类，根据这些类，我们来创建我们相应的产品，为了实现商店类和产品的松耦合，我们定义一个抽象产品类，然后所有的产品都将从这个抽象类继承，然后实现自己的相应的方法，然后通过一个工厂类工厂方法注入实例，实例以委托的形式，来执行相应的操作。
依赖倒置：按照我们的传统思路，我们商店要出售商品，那么我们的商店就要依赖商品，而这里我们从底层的角度去向高层进阶，我们有商品，商品的创建需要一个工厂类，而商店类，则不再依赖于产品，产品也不再依赖于商店类，我们的第一种写法，在商店类中对于我们要创建的类进行的判断，我们就可以将其理解为商品对于商店类的依赖。而现在，其全部依赖于工厂类，通过一个工厂类，实现解耦。同时也使得之前的依赖出现了倒置，又高层依赖底层转为底层依赖高层。

应用实例

实际设计中，工厂模式用的也是比较多，而且这种模式也会比较好辨识，带有Factory。比如Android中的

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

下篇更新状态模式