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

工厂模式
为什么使用工厂模式
应用实例

工厂模式

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

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

为什么使用工厂模式

工厂，生产物品的地方。工厂模式就是用来创建对象，生产对象的。一般，我们会通过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);
}

下篇更新状态模式