设计模式(9)工厂模式(讲解+应用)

java 4 2016-02-29 13:03
女装

目录

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

下篇更新状态模式

女装
文章评论