简单工厂模式实现简易计算器（基于Java语言)

最近在学习设计模式，之前虽然也有学习过，但总是无法领悟其中奥妙，现在主要是利用学习的设计模式来实现一些东西加深了解。

这里采用简单工厂模式实现了一个简易的计算器。

简述

这里简单讲一下我自己对于简单工厂模式的理解，简单工厂模式的核心在类的多态，创建一个所有产品类的父类或父接口，所有的产品类都需要继承或实现父类或父接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

关于简单工厂模式我这里就不详述了，给个链接，有兴趣的可以看一下：https://www.runoob.com/design-pattern/factory-pattern.html

这里来看一下项目的UML图：

这里Operation是所有运算类的父类，在Operation中封装了两个运算数，以及运算得到结果的虚方法，在子类中得到实现。

OperationFactory是运算工厂类，当需要进行运算时，就得这里面去请求，根据输入来让Operation实例为相应的子类。

Main类为界面类，这里将界面和运算逻辑进行解耦。

项目结构：

这里依次贴一下代码：

Main:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--主界面
 */

import javax.swing.*;
import javax.swing.border.BevelBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Main {

    private static Operation operation;


    private JFrame frame=new JFrame("简单工厂模式实现计算器");
    private JPanel panel_show=new JPanel();         //显示面板
    private JMenuBar menuBar=new JMenuBar();
    private JMenu menu1=new JMenu("帮助");
    private JLabel label_hint=new JLabel();    //提示信息标签
    private JLabel label_input=new JLabel();   //输入信息标签
    private JLabel label_result=new JLabel();  //输出结果标签
    private JPanel panel_button=new JPanel();  //按钮面板

    private final String[] str={"AC","←","2","÷","7","8","9","×","4","5","6","-","1","2","3","+","%","0",".","="};
    private JButton[] buttons=new JButton[str.length];

    private static double numberA=0;
    private static double numberB=0;
    private static double result=0;
    private boolean flag=true;                         //记录是否是第一次计算
    private boolean resultIsChange=false;              //判断结果框是否需要更改
    private boolean turn=true;                         //判断当前需要赋值给numberA还是numberB，true为A,false为B


    private static boolean hasOperation=true;          //判断之前是否已经存在操作符
    private static int index=0;                        //记录最后一个操作符位置

    //界面初始化
    private void initJFrame(){
        Container container=frame.getContentPane();
        frame.setSize(600,500);

        //设置窗口居中显示
        frame.setLocationRelativeTo(null);

        //设置菜单栏
        menu1.setFont(new Font("",Font.BOLD,20));
        menuBar.add(menu1);
        frame.setJMenuBar(menuBar);

        //设置提示信息标签
        label_hint.setText(" ");
        label_hint.setHorizontalAlignment(JLabel.RIGHT);
        label_hint.setFont(new Font("宋体",Font.BOLD,30));
        label_hint.setForeground(Color.RED);

        //设置输入标签
        label_input.setText(" ");
        label_input.setHorizontalAlignment(JLabel.RIGHT);
        label_input.setFont(new Font("宋体",Font.BOLD,30));
        label_input.setForeground(Color.BLACK);

        //设置结果标签
        label_result.setText("0");
        label_result.setHorizontalAlignment(JLabel.RIGHT);
        label_result.setFont(new Font("宋体",Font.BOLD,35));
        label_result.setForeground(Color.BLUE);

        panel_show.setLayout(new BorderLayout());
        panel_show.add(label_hint,BorderLayout.NORTH);
        panel_show.add(label_input,BorderLayout.CENTER);
        panel_show.add(label_result,BorderLayout.SOUTH);

        // 创建具有指定类型、高亮显示和阴影颜色的斜面边框。
        panel_show.setBorder(new BevelBorder(BevelBorder.RAISED, new Color(160, 170, 180), null, SystemColor.scrollbar, null));

        panel_button.setLayout(new GridLayout(5, 4, 8, 8));// 按键设置为网格布局5行5列间距为8
        // 创建具有指定类型、高亮显示和阴影颜色的斜面边框。凸出斜面类型。为滚动条提供的背景色。
        panel_button.setBorder(new BevelBorder(BevelBorder.RAISED, new Color(160, 170, 180), null, SystemColor.scrollbar, null));

        //添加按钮
        for(int i=0;i){
            buttons[i]=new JButton(str[i]);
            buttons[i].setFont(new Font("宋体",Font.BOLD,30));

            buttons[i].addActionListener(new MyActionListener());  //为每个按钮添加事件监听器


            panel_button.add(buttons[i]);// 把每个按钮分别添加到面板上

        }

        //把面板添加进窗体框架里
        frame.add(panel_show,BorderLayout.NORTH);
        frame.add(panel_button,BorderLayout.CENTER);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(frame.DISPOSE_ON_CLOSE);
    }

    public static void main(String[] args){
        new Main().initJFrame();
    }



    private class MyActionListener implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            String str=actionEvent.getActionCommand();        //得到触发事件相关的命令字符串
            switch (str){
                case "AC":
                    //清屏操作
                    clear();
                    break;

                case "←":
                    //回退操作修改输入标签
                    String s=label_input.getText();
                    if(s.length()>1){
                        label_input.setText(s.substring(0,s.length()-1));
                    }else{
                        numberA=0;
                        numberB=0;
                        label_input.setText(" ");
                        label_result.setText("0");
                    }

                    //回退操作修改操作符
                    System.out.println(s.length());
                    System.out.println(index);

                    if(s.length()==2){
                        label_result.setText("0");
                        break;
                    }

                    if(s.length()==(index+2)){
                        numberB=0;
                        label_result.setText(""+numberA);
                        break;
                    }

                    if(s.length()==(index+1)){
                        index=0;
                        operation=null;
                        break;
                    }

                    //回退操作修改numberA、B以及结果标签
                    if(index==0){

                        numberA=numberA/10;
                        label_result.setText(""+numberA);
                    }else{
                        numberB=numberB/10;
                        label_result.setText(""+numberB);
                    }
                    break;


                case "2":
                    //平方操作
                    labelInputAppend(str);
                    double d=Double.parseDouble(label_result.getText());
                    label_result.setText(""+d*d);
                    if(turn){
                        numberA=Double.parseDouble(label_result.getText());
                    }else{
                        numberB=Double.parseDouble(label_result.getText());
                    }
                    break;

                case "÷":
                    //除法操作
                    common(str);
                    operation=OperatorFactory.createOperate("÷");
                    resultIsChange=false;
                    break;

                case "×":
                    common(str);
                    operation=OperatorFactory.createOperate("×");
                    resultIsChange=false;
                    break;

                case "-":
                    common(str);
                    operation=OperatorFactory.createOperate("-");
                    resultIsChange=false;
                    break;

                case "+":
                    common(str);
                    operation=OperatorFactory.createOperate("+");
                    resultIsChange=false;
                    break;

                case "%":
                    common(str);
                    operation=OperatorFactory.createOperate("%");
                    resultIsChange=false;
                    break;

                case ".":
                    labelInputAppend(str);
                    lableResultAppend(str);
                    break;

                case "=":
                    //进行计算
                    turn=true;

                    //如果没有按下操作符就按下=
                    if(operation==null){
                        label_result.setText(""+numberA);
                        break;
                    }

                    //当进行除法和模操作时，判断numberB是否为0
                    Object obj=operation.getClass();
                    System.out.println(obj);
                    if(obj.equals(OperationDiv.class)||obj.equals(OperationMod.class)){
                        if(numberB==0.0){
                            label_hint.setText("除数不能为0！");
                            break;
                        }
                    }

                    operation.setNumberA(numberA);
                    operation.setNumberB(numberB);
                    try {
                        result=operation.getResult();
                    } catch (Exception e) {
                        label_hint.setText("抱歉，程序出现错误！");
                        result=0;
                        e.printStackTrace();
                    }
                    label_result.setText(""+result);
                    hasOperation=true;
                    flag=false;  //非第一次计算
                    break;

                default:
                    //所有数字按键进行相同操作
                    labelInputAppend(str);
                    if(!resultIsChange){
                        label_result.setText(str);
                    }else{
                        lableResultAppend(str);
                    }
                    resultIsChange=true;

                    if(turn){
                        numberA=Double.parseDouble(label_result.getText());
                    }else{
                        numberB=Double.parseDouble(label_result.getText());
                    }

                    break;
            }
        }
    }


    //清屏
    private void clear(){
        label_hint.setText(" ");
        label_input.setText(" ");
        label_result.setText("0");
        numberA=0;
        numberB=0;
        result=0;
        turn=true;
        Main.this.flag=true;
        hasOperation=true;
        resultIsChange=false;
    }


    //在输入框中添加字符串
    private void labelInputAppend(String s){
        label_input.setText(label_input.getText()+s);
    }
    
    //在结果框之添加字符串
    private void lableResultAppend(String s){
        label_result.setText(label_result.getText()+s);
    }


    //包装相同操作
    private void common(String str){
        turn=false;
        if(flag){
            if(hasOperation){
                labelInputAppend(str);
                index=label_input.getText().length()-1;
                hasOperation=false;
            }else{
                label_input.setText(label_input.getText().substring(0,label_input.getText().length()-1)+str);
            }
        }else{
            numberA=Double.parseDouble(label_result.getText());
            if(hasOperation){
                labelInputAppend(str);
                index=label_input.getText().length()-1;
                hasOperation=false;
            }else{
                label_input.setText(label_input.getText().substring(0,label_input.getText().length()-1)+str);
            }
        }
    }
}

 Operation:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算父类
 */

public abstract class Operation {
    private double numberA=0;

    private double numberB=0;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public abstract double getResult() throws Exception;
}

 OperationAdd:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符+
 */

public class OperationAdd extends Operation{

    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()+getNumberB();
        return result;
    }
}

 OperationDiv:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符/
 */

public class OperationDiv extends Operation{
    @Override
    public double getResult() throws Exception {
        if(getNumberB()==0){
            throw new Exception("除数不能为0！");
        }
        double result=0;
        result=getNumberA()/getNumberB();
        return result;
    }
}

 OperationMod:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符%
 */

public class OperationMod extends Operation {
    @Override
    public double getResult() throws Exception {
        double result=0;
        result=getNumberA()%getNumberB();
        return result;
    }
}

 OperationMul:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符*
 */

public class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()*getNumberB();
        return result;
    }
}

OperationSub:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符-
 */

public class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()-getNumberB();
        return result;
    }
}

OperationFactory:

package FactoryMethodPattern;

/*
创建人：czc
创建时间：2019/12/16
创建用途：简单工厂模式实现计算器--运算符工厂
 */

abstract class OperatorFactory {
    static Operation createOperate(String operate){
        Operation oper=null;
        switch (operate){
            case "+":
                oper=new OperationAdd();
                break;

            case "-":
                oper=new OperationSub();
                break;

            case "×":
                oper=new OperationMul();
                break;

            case "÷":
                oper=new OperationDiv();
                break;

            case "%":
                oper=new OperationMod();
                break;

            default:
                break;

        }
        return oper;
    }
}

 运行截图：

总的代码就在上面了，其实是主界面占的代码量比较多，简单工厂模式核心的代码就是下面这些父类子类和一个工厂类。

 这个程序并不够健壮，如有错误还请指出，感谢。

总结

总的来说通过继承和多态，降低了程序之间的耦合度，使程序更加灵活，容易修改扩展，并且易于复用。

当然这里简单工厂模式的缺点也很明显，每增加一个运算，就要去增加子类，增加工厂类里的分支。

简单工厂模式主要也应用于业务场景较少，更改较少的情况下。

吾生也有涯，而知也无涯。