工厂模式：摄计魔士和他的炼丹密室

从前有一座山叫爪娲山，山峰上住着一个神龙见首不见尾的道士，江湖上的外号叫摄计魔士，他在密室里放着一座炼丹炉。（抱着娱乐的精神，类名方法名有一些用了中文命名，不规范。在Head First Design Pattern这本书里面，举了一个Pizza店的例子，我觉得很不错。我想了如下这个不同的例子，来说明同样的问题。）本文系原创<br />

为什么需要工厂模式?使用工厂模式有什么好处？可以解决什么问题？

炼丹第一重境界：
摄计魔士刚入行时，涉世不深，只会炼一种丹，所以炼丹的代码比较简陋

public class 丹 {
    public static 丹 makeDan() {
        丹 dan = new 丹();
        dan.准备();
        dan.炼制();
        dan.收工();
        return dan;
    }

    private void 收工() {
        System.out.println("七七四十九天，九九八十一轮回，神丹已成，请您享用");
    }

    private void 炼制() {
        System.out.println("麻利麻利哄，炼制过程开始。。。");
    }

    private void 准备() {
        System.out.println("准备开始炼丹");
    }
}

测试丹.makeDan();，运行结果如下

炼丹第二重境界：（静态工厂方法）
随着炼丹水平的提升，摄计魔士学会了用不同的元素炼丹
丹.class

public class 丹 {
    static 丹 makeDan(String element) {
        丹 dan = null;
        if (element.equals("金")) {
            dan = new 金丹();
        } else if (element.equals("银")) {
            dan = new 银丹();
        } else if (element.equals("铜")) {
            dan = new 铜丹();
        } else if (element.equals("宋丹")) {
            dan = new 宋丹丹();
        }
        if (dan != null) {
            dan.准备();
            dan.炼制();
            dan.收工(element);
        }
        return dan;
    }

    public void 收工(String element) {
        System.out.println("七七四十九天，九九八十一轮回，" + element + "丹已成，请您享用\n");
    }

    public void 炼制() {
        System.out.println("麻利麻利哄，炼制过程开始。。。");
    }

    public void 准备() {
        System.out.println("准备开始炼丹");
    }
}

DanTestDrive.class

public class DanTestDrive {
    public static void main(String[] args) {
        丹.makeDan("金");
        丹.makeDan("宋丹");
    }
}

运行结果：

炼丹第三重境界：（简单工厂）
丹.class

interface 丹 {
    public void 收工();

    public void 炼制();

    public void 准备();
}

金丹.class

public class 金丹 implements 丹 {
    @Override
    public void 收工() {
        System.out.println("炼制完成，用上等的鎏金兽牙盒包装\n");
    }

    @Override
    public void 炼制() {
        System.out.println("金丹炼制中...");
    }

    @Override
    public void 准备() {
        System.out.println("加入黄金二两，秘方若干两");
    }
}

银丹.class

public class 银丹 implements 丹 {
    @Override
    public void 收工() {
        System.out.println("炼制完成，用陈年黑檀木盒包装\n");
    }

    @Override
    public void 炼制() {
        System.out.println("银丹炼制中....");
    }

    @Override
    public void 准备() {
        System.out.println("加入白银二两，秘方若干两");
    }
}

炼丹密室.class

public class 炼丹密室 {
    简丹工厂 factory;

    public 炼丹密室(简丹工厂 factory) {
        this.factory = factory;
    }

    public 丹 makeDan(String element) {
        丹 dan;
        dan = factory.createDan(element);
        dan.准备();
        dan.炼制();
        dan.收工();
        return dan;
    }
}

简丹工厂.class

public class 简丹工厂 {
    丹 createDan(String element) {
        丹 dan = null;
        if (element.equals("金")) {
            dan = new 金丹();
        } else if (element.equals("银")) {
            dan = new 银丹();
        } else if (element.equals("铜")) {
            dan = new 铜丹();
        } else if (element.equals("宋丹")) {
            dan = new 宋丹丹();
        }
        return dan;
    }
}

测试类

public class DanTestDrive {
    public static void main(String[] args) {
        炼丹密室 炼丹密室 = new 炼丹密室(new 简丹工厂());
        炼丹密室.makeDan("金");
        炼丹密室.makeDan("银");
    }
}

运行结果：

结构图：

炼丹第四重境界1：（工厂模式）
摄计魔士带的几个徒弟都出师了，他们是思聪、御凤、强东、芙蓉四大炼丹术士，虽然师出同门，但他们每个人炼丹都有自己的风格，原来一间小小的炼丹密室已经不够用了。<br />
原先是在炼丹密室的构造函数中，传入简丹工厂的引用，然后在炼丹密室的makeDan方法中，调用简丹工厂中的createDan()（dan = factory.createDan(element);），以得到不同种类的丹，现在因为徒弟出师了，师父必须在更高的层次上来设计炼丹的标准。createDan从简丹工厂中移到炼丹密室中，并使之成为抽象方法，从而炼丹密室成为一个抽象类<br />
在此例中可见，“炼丹密室”这个类运用了工厂方法模式，它定义了一个创建对象的接口（createDan），具体要实例化的类（丹类）是哪一个，是由继承“炼丹密室”的子类所决定的。工厂方法让类的实例化推迟到子类中。这样，在炼丹密室这个父类中，所做的是制定流程的事，把不变的部分放在其中，比如将丹类的三个方法按顺序排好，丹需要先准备、然后炼制，最后收工。但是具体的实现过程，因丹而异（比如强东的金丹，他要放入狗粮和奶茶粉的配料）。不能将变动的内容放入到炼丹密室中，每种具体的实现，都由每种不同的丹的子类去实现。

炼丹密室.class

public abstract class 炼丹密室 {
    public 丹 makeDan(String element) {
        丹 dan;
        dan = createDan(element);
        dan.准备();
        dan.炼制();
        dan.收工();
        return dan;
    }

    protected abstract 丹 createDan(String element);
}

思聪的炼丹密室.class

public class 思聪的炼丹密室 extends 炼丹密室 {
    @Override
    protected 丹 createDan(String element) {
        if (element.equals("金")) {
            return new 思聪的秘制金丹();
        } else if (element.equals("银")) {
            return new 思聪的秘制银丹();
        } else {
            return null;
        }
    }
}

思聪的秘制银丹.class

public class 思聪的秘制银丹 implements 丹 {
    @Override
    public void 收工() {
        System.out.println("银丹炼制完成，用明成化斗彩鸡缸杯来装\n");
    }

    @Override
    public void 炼制() {
        System.out.println("银丹炼制中...");
    }

    @Override
    public void 准备() {
        System.out.println("思聪秘制银丹炼制准备。。。");
        System.out.println("放入银两，再加两斤钻石磨成粉");
    }
}

强东的炼丹密室.class

public class 强东的炼丹密室 extends 炼丹密室 {
    @Override
    protected 丹 createDan(String element) {
        if (element.equals("金")) {
            return new 强东的秘制金丹();
        } else if (element.equals("银")) {
            return new 强东的秘制银丹();
        } else {
            return null;
        }
    }
}

强东的秘制金丹.class

public class 强东的秘制金丹 implements 丹 {
    @Override
    public void 收工() {
        System.out.println("用上等的塑料袋包装\n");
    }

    @Override
    public void 炼制() {
        System.out.println("金丹炼制中，等6月18日来拿...");
    }

    @Override
    public void 准备() {
        System.out.println("强东的金丹铺子开张啦。。。");
        System.out.println("金丹准备，加一点点奶茶粉");
    }
}

测试类

public class DanTestDrive {
    public static void main(String[] args) {
        炼丹密室 sicongRoom = new 思聪的炼丹密室();
        sicongRoom.makeDan("银");
        炼丹密室 qiangdongRoom = new 强东的炼丹密室();
        qiangdongRoom.makeDan("金");
    }
}

输出结果：

炼丹第四重境界2：（工厂模式）
师父一看徒弟们炼的丹，完全随心所欲，他决定在质量上面增加一点点把控，于是他做了一些改变，首先就是把原先“丹”由接口变成抽象类
丹.class

public abstract class 丹 {
    String name;
    String roomName;
    String creatorName;
    String packageName;
    List<String> additions = new ArrayList<String>();

    public String getName() {
        return name;
    }

    public void 收工() {
        System.out.println("炼制完成，" + name + "将由" + packageName + "包装\n");
    }

    public void 炼制() {
        System.out.println(name + "正在炼制中。。。");
    }

    public void 准备() {
        System.out.println("爪娲山炼丹密室之" + roomName + "开始炼丹。。。");
        System.out.println("接下来将由" + creatorName + "大师开始炼制" + name);
        System.out.println("架炉生火");
        System.out.println("接下来放入" + roomName + "的秘制配方：");

        for (int i = 0; i < additions.size(); i++) {
            System.out.println("  " + (i+1) + "：" + additions.get(i));
        }
    }
}

强东的秘制银丹.class

public class 强东的秘制银丹 extends 丹 {
    public 强东的秘制银丹() {
        name = "强东的秘制银丹";
        roomName = "强东的炼丹密室";
        creatorName = "强东";
        packageName = "塑料袋";
        additions.add("奶茶粉");
        additions.add("狗粮");
    }
}

思聪的秘制银丹.class

public class 思聪的秘制银丹 extends 丹 {
    public 思聪的秘制银丹() {
        name = "思聪的秘制银丹";
        roomName = "思聪的炼丹密室";
        creatorName = "思聪";
        packageName = "斗彩鸡缸杯";
        additions.add("钻石粉");
        additions.add("一打iphone");
        additions.add("陨石");
    }
}

测试类

public class DanTestDrive {
    public static void main(String[] args) {
        炼丹密室 sicongRoom = new 思聪的炼丹密室();
        sicongRoom.makeDan("银");
        炼丹密室 qiangdongRoom = new 强东的炼丹密室();
        qiangdongRoom.makeDan("银");
    }
}

输出结果：

结构图

炼丹第五重境界：（抽象工厂模式）
一山不容二虎，徒儿们渐渐翅膀长硬了，于是都想着要各奔东西了。原本炼丹，第一味总是要先加入师父提供的秘方，才能够炼制成功。不管是金丹还是银丹，都需要加入它，这味秘方被称为“丹魂”（不是混蛋），即丹的灵魂的意思。摄计魔士知道徒儿们的心思，于是意味深长地和徒儿们道出了秘方：丹魂是由三种东西构成的：清晨的露水，白色的羽毛以及若干种兽骨，唯有丹魂，才有神丹。金丹的丹魂是清晨的露水、白色的羽毛及若干种兽骨 ，银丹的丹魂是清晨的露水和白色的羽毛，铜丹的丹魂只需要清晨的露水。

	金丹	银丹	铜丹
清晨的露水	√	√	√
白色的羽毛	√	√	<br />
若干种兽骨	√	<br />	<br />

其中御凤去了亚美利加大洲，她炼制金丹时，用了美洲雕的羽毛，清晨中央公园嫩叶上的露水以及火鸡骨和北美的野牛骨作为丹魂。而思聪则留在了大陆，他炼制金丹时，用了兰博基尼上的新鲜露水、白凤凰的羽毛以及麒麟、獬豸和貔貅骨头作为丹魂。

丹魂工厂.class

public interface 丹魂工厂 {
    public 露水 createDew();

    public 羽毛 createFeather();

    public 兽骨[] createBones();

    public 金 createGold();

    public 银 createSilver();

    public 铜 createBronze();

}

思聪丹魂工厂.class

public class 思聪丹魂工厂 implements 丹魂工厂 {
    @Override
    public 露水 createDew() {
        return new 兰博基尼上的新鲜露水();
    }

    @Override
    public 羽毛 createFeather() {
        return new 白凤凰羽();
    }

    @Override
    public 兽骨[] createBones() {
        兽骨[] bones = {new 麒麟骨(), new 獬豸骨(), new 貔貅骨()};
        return bones;
    }

    @Override
    public 金 createGold() {
        return new 金();
    }

    @Override
    public 银 createSilver() {
        return new 银();
    }

    @Override
    public 铜 createBronze() {
        return new 铜();
    }
}

御凤丹魂工厂.class

public class 御凤丹魂工厂 implements 丹魂工厂 {
    @Override
    public 露水 createDew() {
        return new 中央公园新鲜露水();
    }

    @Override
    public 羽毛 createFeather() {
        return new 美洲雕白羽();
    }

    @Override
    public 兽骨[] createBones() {
        兽骨[] bones = {new 火鸡骨(), new 北美野牛骨()};
        return bones;
    }

    @Override
    public 金 createGold() {
        return new 金();
    }

    @Override
    public 银 createSilver() {
        return new 银();
    }

    @Override
    public 铜 createBronze() {
        return new 铜();
    }

}

丹.class

该类与之前的区别就在于，将“准备()”变成了一个抽象方法，由子类去实现

public abstract class 丹 {
    String name;
    String roomName;
    String creatorName;
    String packageName;
    露水 dew;
    羽毛 feather;
    兽骨[] bones;
    金 gold;
    银 silver;
    铜 bronze;
    List<String> additions = new ArrayList<String>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void 收工() {
        System.out.println("炼制完成，" + name + "将由" + packageName + "包装\n");
    }

    public void 炼制() {
        System.out.println(name + "正在炼制中。。。");
    }

    abstract void 准备();
}

金丹.class

public class 金丹 extends 丹 {
    丹魂工厂 ingredientFactory;

    public 金丹(丹魂工厂 ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }


    @Override
    void 准备() {
        System.out.println("开始炼制" + name);
        dew = ingredientFactory.createDew();
        feather = ingredientFactory.createFeather();
        bones = ingredientFactory.createBones();
        gold = ingredientFactory.createGold();
        System.out.println("构成金丹的丹魂是：" +
                        dew.getClass().getSuperclass().getSimpleName() + "、" +
                        feather.getClass().getSuperclass().getSimpleName() + "和兽骨"
        );
        System.out.println(name + "的丹魂配方由"
                        + dew.getClass().getSimpleName() + "、"
                        + feather.getClass().getSimpleName() + "以及若干兽骨所组成"
        );
        System.out.println("其中兽骨的配方包含：");
        for (int i = 0; i < bones.length; i++) {
            System.out.println("  " + (i + 1) + "." + bones[i].getName());
        }
    }
}

银丹.class

public class 银丹 extends 丹 {
    丹魂工厂 ingredientFactory;

    public 银丹(丹魂工厂 ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    public void 准备() {
        System.out.println("开始炼制" + name);
        dew = ingredientFactory.createDew();
        feather = ingredientFactory.createFeather();
        silver = ingredientFactory.createSilver();
        System.out.println("构成银丹的丹魂是："
                + dew.getClass().getSuperclass().getSimpleName() + "和"
                + feather.getClass().getSuperclass().getSimpleName());
        System.out.println(name + "的丹魂配方由"
                        + dew.getClass().getSimpleName() + "、"
                        + feather.getClass().getSimpleName() + "所组成"
        );
    }
}

思聪的秘制银丹.class

public class 思聪的秘制银丹 extends 银丹 {
    public 思聪的秘制银丹(丹魂工厂 ingredientFactory) {
        super(ingredientFactory);
        packageName = "斗彩鸡缸杯";
    }
}

思聪的秘制金丹.class

public class 思聪的秘制金丹 extends 金丹 {

    public 思聪的秘制金丹(丹魂工厂 ingredientFactory) {
        super(ingredientFactory);
        packageName = "斗彩鸡缸杯";
    }
}

御凤的秘制金丹.class

public class 御凤的秘制金丹 extends 金丹 {

    public 御凤的秘制金丹(丹魂工厂 ingredientFactory) {
        super(ingredientFactory);
        packageName = "首饰盒";
    }
}

炼丹密室.class

public abstract class 炼丹密室 {
    public 丹 makeDan(String element) {
        丹 dan;
        dan = createDan(element);
        dan.准备();
        dan.炼制();
        dan.收工();
        return dan;
    }

    protected abstract 丹 createDan(String element);
}

思聪的炼丹密室.class

public class 思聪的炼丹密室 extends 炼丹密室 {
    @Override
    protected 丹 createDan(String element) {
        丹 dan = null;
        丹魂工厂 ingredientFactory = new 思聪丹魂工厂();
        if (element.equals("金")) {
            dan = new 思聪的秘制金丹(ingredientFactory);
            dan.setName("思聪金丹");
        } else if (element.equals("银")) {
            dan = new 思聪的秘制银丹(ingredientFactory);
            dan.setName("思聪银丹");
        } else if (element.equals("铜")) {
            dan = new 铜丹(ingredientFactory);
            dan.setName("思聪铜丹");
        }
        return dan;
    }
}

御凤的炼丹密室.class

public class 御凤的炼丹密室 extends 炼丹密室 {
    @Override
    protected 丹 createDan(String element) {
        丹 dan = null;
        丹魂工厂 ingredientFactory = new 御凤丹魂工厂();
        if (element.equals("金")) {
            dan = new 御凤的秘制金丹(ingredientFactory);
            dan.setName("御凤金丹");
        } else if (element.equals("银")) {
            dan = new 御凤的秘制银丹(ingredientFactory);
            dan.setName("御凤银丹");
        }
        return dan;
    }
}

测试类

public class DanTestDrive {
    public static void main(String[] args) {
        炼丹密室 sicongRoom = new 思聪的炼丹密室();
        sicongRoom.makeDan("金");
        sicongRoom.makeDan("银");
        炼丹密室 yufengRoom = new 御凤的炼丹密室();
        yufengRoom.makeDan("金");
    }
}

运行结果：

有一天思聪心血来潮，想用一下御凤的丹魂配方，于是他只用改一个地方，即把思聪丹魂工厂改成御凤丹魂工厂。神奇的事情就发生了，只需要改动一处，他的配方就变成了御凤的配方。
思聪的炼丹密室.class

public class 思聪的炼丹密室 extends 炼丹密室 {
    @Override
    protected 丹 createDan(String element) {
        丹 dan = null;
        丹魂工厂 ingredientFactory = new 御凤丹魂工厂();
        if (element.equals("金")) {
            dan = new 思聪的秘制金丹(ingredientFactory);
            dan.setName("思聪金丹");
        } else if (element.equals("银")) {
            dan = new 思聪的秘制银丹(ingredientFactory);
            dan.setName("思聪银丹");
        } else if (element.equals("铜")) {
            dan = new 铜丹(ingredientFactory);
            dan.setName("思聪铜丹");
        }
        return dan;
    }
}

运行结果：

丹魂工厂这个类便是运用了抽象工厂模式，它以接口的形式提供出了一份创建对象的协议，其中是丹魂的配方，包含露水、白色羽毛和兽骨组合。它只是说丹魂需要这三种成份，具体是用纽约中央公园的新鲜露水还是兰博基尼上面的新鲜露水，它不需要管，由其子类来具体实现，比如御凤丹魂工厂、思聪丹魂工厂。

结构示意图