四则运算法则表延伸 － 工厂方法模式

工厂方法模式

简介

定义了一个建立对象的抽象方法，由子类决定要实例化的类

工厂方法的模式将对象的实例化推迟到子类

组成角色

• 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
• 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。在java中它由具体的类来实现。
• 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中通常有抽象类或者接口来实现。
• 具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在java中由具体的类来实现。

优缺点

• 优势

  • 一个调用者想建立一个对象，只要知道其名称就能够了。
  • 扩展性高，若是想增长一个产品，只要扩展一个工厂类就能够。
  • 屏蔽产品的具体实现，调用者只关心产品的接口。

• 缺点

  • 每次增长一个产品时，都须要增长一个具体类和对应的实现工厂，使得系统中类的个数成倍增长，在必定程度上增长了系统的复杂度，同时也增长了系统具体类的依赖。

适用场景

• 当一个类不知道它所必须建立的对象的类的时候。
• 当一个类但愿由它的子类来指定它所建立的对象的时候。
• 当类将建立对象的职责委托给多个帮助子类中的某一个，而且你但愿将哪个帮助子类是代理者这一信息局部化的时候。

注意事项

• 做为一种建立类模式，在任何须要生成复杂对象的地方，均可以使用工厂方法模式。有一点须要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只须要经过 new 就能够完成建立的对象，无需使用工厂模式。若是使用工厂模式，就须要引入一个工厂类，会增长系统的复杂度。

案例

四则运算表

大牛：“小鸟，你又没有发现，使用简单工厂去设计四则运算表的时候，其实对于LowTableFactory类来讲是违背了开闭原则的。”

小鸟：“发现了，若是我要增长其它的算法表的类，那么同时我也要去修改LowTableFactory类，给其添加一个case。”

大牛：“说的不错，对于这个问题，你有什么好的解决思路呢？”

小鸟：“个人解决方法就是，使用工厂方法模式，如下就是个人代码（以加法表和乘法表为例）”

抽象产品角色：AFourOperations

四则运算法则

public abstract class AFourOperations {
    public abstract void operations();
}

具体产品角色1：AddOperations

加法表

public class AddOperations extends AFourOperations {

    @Override
    public void operations() {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(String.format("%d+%d=%d\t", j, i, i + j));
            }
            System.out.println("");
        }
    }
}

具体产品角色2：MultiplicationOperations

乘法表

public class MultiplicationOperations extends AFourOperations {
    @Override
    public void operations() {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(String.format("%d*%d=%d\t", j, i, i * j));
            }
            System.out.println("");
        }
    }
}

抽象工厂角色：IFourOperationsFactory

工厂类

public abstract class AFourOperationsFactory {
    public abstract AFourOperations createFourOperations();
}

具体工厂角色1：AddOperationsFactory

加法工厂

public class AddOperationsFactory extends AFourOperationsFactory {

    @Override
    public AFourOperations createFourOperations() {
        return new AddOperations();
    }
}

具体工厂角色2：MultiplicationOperationsFactory

乘法工厂

public class MultiplicationOperationsFactory extends AFourOperationsFactory {
    @Override
    public AFourOperations createFourOperations() {
        return new MultiplicationOperations();
    }
}

客户端调用

AFourOperationsFactory factory = new MultiplicationOperationsFactory();
AFourOperations aFourOperations = factory.createFourOperations();
aFourOperations.operations();

大牛：“嗯嗯，不错，结构很清晰!”

小鸟：“牛哥，我发现这个还不如简单工厂好用呢！这里每建立一个类，就得为其建立对应的工厂,感受无形中增长了好多类啊!”

大牛：“确实，这就是工厂方法模式和简单工厂的一个最大区别，工厂方法模式虽然增长了不少类，但它更符合开－闭原则，下降了客户端与后台的耦合度”