工厂模式及其拓展

工厂模式UML图

闲言

最近鄙人在看《设计模式之禅》这本书，巩固一下常用的设计模式，本文的例子就直接用的书中的例子，因为作者写的通俗易懂，让我看的欲罢不能，给作者大大比心！！（其实我就是懒）
工厂模式的优点自不必说，首先，良好的封装性，在使用的时候我们不必考虑对象创建的各种约束条件，只需要知道要生产的产品的类名就可以了。其次，优秀的可拓展性，如果业务有变化，需要增加或者删除一个产品类，只需要修改工厂类就可以了，做到了真正的拥抱变化。最后，工厂模式是典型的解耦框架，符合迪米特法则，也符合依赖倒置的原则。

1.工厂模式定义

工厂模式在我们日常开发中式使用频率非常高的一种设计模式，其定义为：定义一个用于创建对象的接口，让子类决定创建那个类，该模式使一个类的实例化延迟到其子类。

也就是说我们创建一个接口，用这个接口去生产具体的类，不用关心类是怎么创建的，如何初始化，只须关心要生产的是具体哪一个类，至于如何创建，我们去交给工厂来实现。

2.通用实现

以上图女娲造人为例，我们现在要生产出具体肤色的人，先创建一个接口AbstractHumanFactory，用于规定工厂中创建人类的方法，再创建一个人类的接口，里面规定了无论那种肤色的人都有的方法，肤色和语言，方法的具体实现由下面具体肤色的人来实现。下面上代码：

//抽象工厂类
public abstract class AbsFactory {
    public abstract T createHuman(Class cls);
}

//人类接口
interface Human {
    void getColor();
    void talk();
}

//工厂类
public class FactoryImpl extends AbsFactory{
    @Override
    public  T createHuman(Class cls) {
        Human human=null;

        try {
            human=(T)Class.forName(cls.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("创建人类失败");
        }
        return (T)human;
    }
}

//黑人
public class BlackHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("我是黑种人，我的皮肤是黑色的。");
    }

    @Override
    public void talk() {
        System.out.println("一般人听不懂黑人在说什么。");
    }
}

//黄种人
public class YellowHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("我是黄种人，我的皮肤是黄色的。");
    }

    @Override
    public void talk() {
        System.out.println("我们黄种人说的一般都是双字节");
    }
}

//白人
public class WhiteHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("我是白种人，我的皮肤是白色的。");
    }

    @Override
    public void talk() {
        System.out.println("白种人说的一般都是单字节。");
    }
}

下面是场景类，也就是我们的使用场景：

public class NvWa {
    public static void main(String[] args) {
        AbsFactory factory=new FactoryImpl();
        Human white=factory.createHuman(WhiteHuman.class);
        white.getColor();
        white.talk();

        Human yellow=factory.createHuman(YellowHuman.class);
        yellow.getColor();
        yellow.talk();

        Human black=factory.createHuman(BlackHuman.class);
        black.getColor();
        black.talk();

    }
}

运行结果：
我是白种人，我的皮肤是白色的。
白种人说的一般都是单字节。
我是黄种人，我的皮肤是黄色的。
我们黄种人说的一般都是双字节
我是黑种人，我的皮肤是黑色的。
一般人听不懂黑人在说什么。

Process finished with exit code 0

以上就是工厂模式的通用实现。

3.简单工厂模式

简单工厂示UML图

在类图中，我们把AbsstractHumanFactory删除，同时把HumanFactory中的createHuman方法修改成静态方法，而在我们的场景类NvWa中也要做相应修改。

//工厂类
public class FactoryImpl{
    public static  T createHuman(Class cls) {
        Human human=null;

        try {
            human=(T)Class.forName(cls.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("创建人类失败");
        }
        return (T)human;
    }
}

//场景类
public class NvWa {
    public static void main(String[] args) {
        Human white=FactoryImpl.createHuman(WhiteHuman.class);
        white.getColor();
        white.talk();

        Human yellow=FactoryImpl.createHuman(YellowHuman.class);
        yellow.getColor();
        yellow.talk();

        Human black=FactoryImpl.createHuman(BlackHuman.class);
        black.getColor();
        black.talk();

    }
}

运行结果：
我是白种人，我的皮肤是白色的。
白种人说的一般都是单字节。
我是黄种人，我的皮肤是黄色的。
我们黄种人说的一般都是双字节
我是黑种人，我的皮肤是黑色的。
一般人听不懂黑人在说什么。

简单工厂的应用场景：当一个模块只需要一个工厂类，没有必要把他生产出来，使用静态方法就可以了。

这句话是书上的原话，其实我是没怎么看懂，但是后来看到后面还有多工厂模式，我就明白了。有时候，业务比较复杂，很多产品的创建方式，对对象的属性值得初始化都不相同，如果都放到一个工厂中去，会使代码结构不清晰，所以我们为每一个产品（或创建方式一致的一类产品）都定义一个工厂，于是，多工厂模式诞生了。如果业务逻辑比较简单的时候，一个工厂就可以搞定所有产品的生产的时候，我们就用简单工厂模式。下面我们来学习一下工厂模式的另一个变种。

4.多工厂模式

多工厂模式UML图

我们在AbstractHumanFactory中的抽象方法中去掉了传参，因为每一个具体的工厂的职责都非常明确，创建自己负责的产品类对象。女娲类也需要做相应修改。

public abstract class AbsFactory {
    public abstract T createHuman();
}

public class BlackHumanFactory extends AbsFactory{
    @Override
    public Human createHuman() {
        return new BlackHuman();
    }
}

public class WhiteHumanFactory extends AbsFactory{
    @Override
    public Human createHuman() {
        return new WhiteHuman();
    }
}

public class YellowHumanFactory extends AbsFactory{
    @Override
    public Human createHuman() {
        return new YellowHuman();
    }
}

public class NvWa {
    public static void main(String[] args) {
        Human white=(new WhiteHumanFactory()).createHuman();
        white.getColor();
        white.talk();

        Human yellow=(new YellowHumanFactory()).createHuman();
        yellow.getColor();
        yellow.talk();

        Human black=(new BlackHumanFactory()).createHuman();
        black.getColor();
        black.talk();

    }
}

运行结果和上面一样，这里不再展示。