五、工厂方法模式——设计模式学习笔记

作为一个编程菜鸟，过去在学习设计模式的时候，老师给推荐了一本《大话设计模式》。阅读以后受益匪浅，可惜当初没有坚持看完。
最近有时间了，又重新捡起来学习了一遍，整理了一下笔记，由于本人能力有限，欢迎大家批评指正。

1.工厂方法模式 Factory Method

• 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
• 工厂方法模式是一种常用的对象创建型设计模式，此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂、具体工厂、抽象产品、具体产品。
• 工厂方法模式首先完全实现“开-闭原则”，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。工厂方法模式是最典型的模板方法模式应用。

2.uml类图

3.组成

（1）抽象工厂角色

是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

（2）具体工厂角色

这是实现抽象工厂接口的具体工厂类，包含于应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

（3）抽象产品角色

工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

（4）具体产品角色：

这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

4.应用场景

• 第一种情况是对于某个产品，调用者清楚地知道应用使用哪个具体工厂服务，实例化该具体工厂，生产出没具体的产品来。Java Collection中的iterator()方法即属于这种情况。
• 第二种情况，只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程对于使用者来说是透明的。

5.实例

（1）需求

根据需要执行对应的运算。

（2）uml类图

（3）代码

a.算法工厂抽象类

package com.longinus.fm;
public abstract class Factory {
    public abstract Operation createOperation();
}

b.具体算法产品工厂类

package com.longinus.fm;
public class AddFactory extends Factory{
    @Override
    public Operation createOperation() {
        // TODO 自动生成的方法存根
        return new Add();
    }

}

package com.longinus.fm;
public class SubFactory extends Factory{
    @Override
    public Operation createOperation() {
        // TODO 自动生成的方法存根
        return new Sub();
    }
}

package com.longinus.fm;
public class MulFactory extends Factory{
    @Override
    public Operation createOperation() {
        // TODO 自动生成的方法存根
        return new Mul();
    }
}

package com.longinus.fm;
public class DivFactory extends Factory{
    @Override
    public Operation createOperation() {
        // TODO 自动生成的方法存根
        return new Div();
    }
}

c.算法产品抽象类

package com.longinus.fm;
public abstract class Operation {
    private double NumberA;
    private double NumberB;

    public double getNumberA() {
        return NumberA;
    }
    public void setNumberA(double numberA) {
        NumberA = numberA;
    }
    public double getNumberB() {
        return NumberB;
    }
    public void setNumberB(double numberB) {
        NumberB = numberB;
    }
    public abstract double getResult();

}

d.具体算法产品类

package com.longinus.fm;
public class Add extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumberA() + getNumberB();
    }
}

package com.longinus.fm;
public class Sub extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumberA() - getNumberB();
    }
}

package com.longinus.fm;
public class Mul extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumberA() * getNumberB();
    }
}

package com.longinus.fm;
public class Div extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        if(getNumberB() == 0){
            throw new ArithmeticException();
        }
        return getNumberA() / getNumberB();
    }
}

e.测试类

package com.longinus.fm;

public class Test {
    public static void main(String[] args) {
        Factory of = new AddFactory();
        Operation op = of.createOperation();
        op.setNumberA(6);
        op.setNumberB(2);
        System.out.println(op.getResult());

        of = new SubFactory();
        op = of.createOperation();
        op.setNumberA(6);
        op.setNumberB(2);
        System.out.println(op.getResult());

        of = new MulFactory();
        op = of.createOperation();
        op.setNumberA(6);
        op.setNumberB(2);
        System.out.println(op.getResult());

        of = new DivFactory();
        op = of.createOperation();
        op.setNumberA(6);
        op.setNumberB(2);
        System.out.println(op.getResult());
    }
}

f.输出结果

8.0
4.0
12.0
3.0

5.简单工厂与工厂方法

• 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是当需求变化，需要扩展时就需要修改工厂类的代码，这违背了开放-封闭原则。
• 工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。
• 工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。它们都是集中封装了对象的创建，使得要更换对象时，不需要做大的改动就可实现，降低了客户程序与产品对象的耦合。
• 利用“反射”可以解决避免分支判断的问题。