Java实现简单工厂模式—GoF(一)

Edited on In ,

前言

开始设计模式之初，要多说两句。

今天工作整整两年！长时间的基础编程，使我代码掌握的很熟练，通过前辈们的推荐以及众多前辈的博文，在未来的两年里，我给我自己总结了一份学习路径，就以书的形式推进下去。

  1. 《大话设计模式》或《研磨设计模式》
  2. 《重构 改善既有代码的设计》
  3. 《effective java》
  4. 《深入理解Java虚拟机》
  5. 《Java并发编程实战》
  6. 《深入理解计算机系统》

除此之外，闲暇之余多阅读一下JDK源码，了解其原理，以及JDK中工具的使用（JDK中的工具类，大多都是优化过的，比自己写的强多了）。

之前开发经验尚浅，只能写一些自己平常用到的环境安装、自己解决的问题、自己日常的学习记录。

大话设计模式之前也读过一两遍，由于没有什么经验，也是一知半解，趁着这个有意义的时间节点，开始学习一些深入的知识，现在就从最初的开始。

为什么要学习设计模式？

  1. 在软件开发领域，经过验证的，用于解决在特定环境下，重复出现的特定问题的解决方案！ ——引用自《研磨设计模式》
  2. 学习设计模式是个人技术能力的提高的捷径
  3. 不用重复发明轮子

为什么要写博文？

虽然写的博文大多都 差强人意，但为什么还是要写呢？

于自己，博文是自己的总结，学进的东西，能讲出来才是最好的学。

于读者，通过我写的博文，能获取到知识点，那这篇博文就有存在的意义。

简单工厂模式

(1) 一个实现一个计算器

简单工厂模式比较简单，直接就引用《大话数据模式》中的示例。

示例中含有：

  • OperationFactory 工厂
  • Operation 操作类基类
  • OperationAdd 加法操作
  • OperationSub 减法操作
  • OperationMul 乘法操作
  • OperationDiv 除法操作

下面来看具体实现：

1）操作类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/**
 * 操作基类
 */
class Operation {
    double numA;
    double numB;

    double getResult() {
        return 0;
    }
}

/**
 * +
 */
class OperationAdd extends Operation {

    @Override
    public double getResult() {
        return numA + numB;
    }
}

/**
 * -
 */
class OperationSub extends Operation {

    @Override
    public double getResult() {
        return numA - numB;
    }
}

/**
 * *
 */
class OperationMul extends Operation {

    @Override
    public double getResult() {
        return numA * numB;
    }
}

/**
 * /
 */
class OperationDiv extends Operation {

    @Override
    public double getResult() {
        return numA / numB;
    }
}

2）工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 实现一个拥有 + - * / 功能的简单计算器
 *
 * @from 大话设计模式
 */
class OperationFactory {
    /**
     * 生产计算
     *
     * @param operate 操作符号
     * @return 产出操作
     */
    public static Operation createOperation(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
        }
        return operation;
    }
}

2）测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        /*操作工厂产出 + 的操作，后面赋值获取结果*/
        Operation operation = OperationFactory.createOperation("+");
        operation.numA = 1;
        operation.numB = 1;
        System.out.println(operation.numA + "+" + operation.numB + "=" + operation.getResult());
        /*操作工厂产出 * 的操作，后面赋值获取结果*/
        Operation operationMul = OperationFactory.createOperation("*");
        operationMul.numA = 2;
        operationMul.numB = 3;
        System.out.println(operationMul.numA + "+" + operationMul.numB + "=" + operationMul.getResult());
    }
}

这里会输出结果

1
2
1.0+1.0=2.0
2.0+3.0=6.0

一个简单工厂模式就这样实现了。

具体使用还要结合实际业务进行不同程度的修改，给大家介绍一个比较实际的业务。

(2) 另一个实际使用的业务

抛开业务讲实现方案都是刷流氓

价格数据计算问题，这里就不展示代码了。

大概业务就是：计算商品价格的同比、环比、累计比等结果(每天午间新闻都会讲的那种价格数据)。某一系列的价格数据构成一个数组，这个数组数据可以计算为同比、环比等。

计算这些价格数据，它有不同的公式，也就是说输入的数据是一样的，但是计算公式相同产生的结果不同。

为了保证公式的可扩展性，我就使用了简单工厂模式处理这个公式计算问题。

  • CalculateFactory 计算公式工厂类（类名虚构）
  • IFormulaOperation 计算公式操作接口，这里用接口而不是父类，是因为接口更加灵活，也用到了JDK1.8中的新特性（default 方法等）。
  • FormulaA 拉式公式（类名虚构）
  • FormulaB 派式公示（类名虚构）
  • …….

代码实现思路与上面的计算器的实现是相差不大的，就是代码复杂了很多，当了解这个工厂模式了，就很容易看的懂代码了，而且同事之前讨论也比较方便。

最后，有一句话想说，即使有聪明的人一两遍就理解并使用了很多设计模式，但是在这里还是建议大家有空多回顾回顾，就我自己而言，每次看设计模式，都有不一样的想法和思路，还有可能对以前业务有更新奇的解决方案。

本文地址：Java实现简单工厂模式—GoF(一)

本文地址： https://github.com/maxzhao-it/blog/post/47074/