设计模式（9）工厂模式（讲解+应用）

目录

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);
}

下篇更新状态模式