欢迎大家扫码关注我的微信公众号：
数据之恋

设计模式 之 简单工厂模式-计算器程序

一、需求

设计一个简单的计算器程序， 要求给定两个数字及运算符号后， 输出对应的结果。

二、 普通实现

采用 Java 语言实现。
如果只是简单的实现的话， 可以使用下面的程序：

package com.atguigu.JavaSchema.SimpleFactory;

import java.util.Scanner;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-15:48
 */
public class Operating {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        try {
            System.out.println("请输入一个整数：");
            double NumberA = scan.nextDouble();
            System.out.println("请输入另一个整数：");
            double NumberB = scan.nextDouble();
            System.out.println("请输入要进行的操作（+-*/）：");
            String operate = scan.next();

            double result = 0;
            switch (operate) {
                case "+":
                    result = NumberA + NumberB;
                    break;
                case "-":
                    result = NumberA - NumberB;
                    break;
                case "*":
                    result = NumberA * NumberB;
                    break;
                case "/":
                    result = NumberA / NumberB;
                    break;
            }

            System.out.println(NumberA + operate + NumberB + " = " + result);
        } catch (Exception e) {
            System.out.println("Error happend: " + e.getMessage());
        }
    }
}

但是这样的程序不易维护、不易扩展， 也不易复用。 而且一旦我想加个开方的功能， 则需要全部都进行修改、编译。
可以使用面向对象的方式， 将程序松耦合（计算和展示分开）， 使用简单工厂模式， 将程序变得易维护、易扩展、易复用。

三、 简单工厂模式实现

3.1 给出一个 Operation 类

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:09
 */
public class Operation {
    double NumberA = 0;
    double NumberB = 0;

    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 double getResutl() throws Exception {
        double result = 0;
        return result;
    }
}

3.2 分别新建四个类对应加减乘除的四个方法

加：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:27
 */
public class OperAdd extends Operation {

    @Override
    public double getResutl() {
        double result;
        result = NumberA + NumberB;
        return result;
    }
}

减：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:31
 */
public class OperSub extends Operation {

    @Override
    public double getResutl() {
        double result;
        result = NumberA - NumberB;
        return result;
    }
}

乘：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:32
 */
public class OperMul extends Operation {

    @Override
    public double getResutl() {
        double result;
        result = NumberA * NumberB;
        return result;
    }
}

除：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:33
 */
public class OperDiv extends Operation {

    @Override
    public double getResutl() throws Exception {
        double result;
        if (NumberB == 0) {
            throw new Exception("除数不能为 0.");
        }
        result = NumberA / NumberB;
        return result;
    }
}

3.3 新建一个简单工厂类：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:38
 */
public class OperFactory {

    public static Operation createOperate(String operate) {
        Operation oper;
        switch (operate) {
            case "+":
                oper = new OperAdd();
                break;
            case "-":
                oper = new OperSub();
                break;
            case "*":
                oper = new OperMul();
                break;
            default:
                oper = new OperDiv();
                break;
        }
        return oper;
    }
}

3.4 新建一个展示信息的类：

package com.atguigu.JavaSchema.SimpleFactory.SchemaImplete;

import java.util.Scanner;

/**
 * @ author: cybeyond
 * @ create: 2020-04-06-16:41
 */
public class ShowOper {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        try {
            System.out.println("请输入一个整数：");
            double NumberA = scan.nextDouble();
            System.out.println("请输入另一个整数：");
            double NumberB = scan.nextDouble();
            System.out.println("请输入要进行的操作（+-*/）：");
            String operate = scan.next();

            Operation oper = OperFactory.createOperate(operate);
            oper.setNumberA(NumberA);
            oper.setNumberB(NumberB);
            double result = oper.getResutl();

            System.out.println(NumberA + operate + NumberB + " = " + result);
        } catch (Exception e) {
            System.out.println("Error happend: " + e.getMessage());
        }
    }
}

这样就完成简单工厂模式下的计算器程序（参数判断未做全）。
如果有需求新增一个开方的运算， 只需要修改一下OperFactory类同时新增一个子类即可， 不必将原来的所有程序都拿过来去修改， 可以避免手抖造成其他不需要修改的程序被错误的修改。

3.5 使用Python语言实现的版本：

使用 Python 2.7 版本可以如此实现：

class Operation(object):

    def __init__(self):
        self.num_a = 0
        self.num_b = 0

    def set_num_a(self, value):
        self.num_a = value

    def set_num_b(self, value):
        self.num_b = value

    def get_result(self):
        pass


class OperAdd(Operation):

    def get_result(self):
        return self.num_a + self.num_b


class OperSub(Operation):

    def get_result(self):
        return self.num_a - self.num_b


class OperMul(Operation):

    def get_result(self):
        return self.num_a * self.num_b


class OperDiv(Operation):

    def get_result(self):
        if self.num_b == 0:
            raise Exception("B cannot be zero.")
        return self.num_a / self.num_b


class OperFactory(object):

    @classmethod
    def create_operation(cls, operate):
        if operate == '+':
            oper = OperAdd()
        elif operate == '-':
            oper = OperSub()
        elif operate == '*':
            oper = OperMul()
        else:
            oper = OperDiv()
        return oper


class ShowInfo(object):

    @classmethod
    def run(cls):
        try:
            num_a = int(raw_input('Please input number A: '))
            num_b = int(raw_input('Please input number B: '))
            operate = raw_input('Please input operator(+ - * /): ')
            
            oper = OperFactory.create_operation(operate)
            oper.set_num_a(num_a)
            oper.set_num_b(num_b)
            result = oper.get_result()

            print '%s %s %s = %s' % (num_a, operate, num_b, result)
        except Exception as e:
            print 'Error happened: %s' % e


if __name__ == '__main__':
    ShowInfo.run()
# 设计模式 # java
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

KingbaseES数据库：医疗信创潮涌沅江，国产化信创打造医疗新质生产力

avatar DAMO开发者矩阵
cover

告别迁移焦虑：金仓KDMS V4带你轻松搞定数据库国产化替代

avatar DAMO开发者矩阵
cover

KingbaseES数据库在常德二院全栈国产化信创中产生新质生产力,医疗信创的部署如何实现，如何操作？

avatar DAMO开发者矩阵