Java计算器设计实现

た入场券 2021-09-28 21:20 400阅读 0赞

### 文章目录 ###

*  需求分析
 *  设计思路
 *  设计实现
 *  设计实现展示
 *  其他功能

# 需求分析 #

*  目的是实现一个基于Java的可以**求解带括号加减乘除表达式**的**带界面**的计算器。
 *  需要知道的Java技术：Java Swing（Java图形界面设计）、Java集合（栈）、lambda表达式、Java基础等。

# 设计思路 #

1.  实现一个Java计算器界面类
2.  实现一个Java计算带括号加减乘除表达式的类
3.  实现主函数调用

# 设计实现 #

*  Java计算器项目结构：  
    ![计算器项目程序目录结构][20190601190542867.png]  
    Calculator类为计算器界面设计、Calculate类为计算带括号加减乘除表达式的类，Main函数为项目程序入口。
 *  Java计算器界面设计实现代码：

package Calculator;
    
    import java.awt.BorderLayout;
    import java.awt.CardLayout;
    import java.awt.Dimension;
    import java.awt.GridLayout;
    import java.awt.TextField;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JMenuItem;
    import javax.swing.JPanel;
    import javax.swing.JTextField;
    
    public class Calculator extends JFrame{ 
    		
    	private double result=0;
    	private int count=0;
    	
    	public Calculator() { 
    		this.setSize(330,399);		
    		this.setTitle("计算器");		
    		init();
    // this.pack();
    		this.setVisible(true);
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
    	}
    	
    	public void init() { //初始化界面
    		
    		this.setLayout(new BorderLayout()); //总体布局为边框式布局
    		
    		/* * 总体边框式布局north放置文本框 */		
    		JTextField textField=new JTextField();
    		textField.disable();
    		textField.setPreferredSize(new Dimension(this.getWidth(),50));
    		this.add(textField,BorderLayout.NORTH);
    
    		/* * 总体边框式布局center放置@panel(边框式布局） * @panel边框式布局north放置@panelN(网格布局) * @panel边框式布局center放置@panelC(卡片式布局) * @panelC卡片来切换@panel0(标准)和@panel1(科学)两种模式 * @panel0,@panel1均为网格布局 */					
    		JPanel panel=new JPanel();
    		panel.setLayout(new BorderLayout());
    		this.add(panel, BorderLayout.CENTER);
    		
    		JPanel panelN=new JPanel();
    		panelN.setLayout(new GridLayout(1,6));
    		JButton MC=new JButton("MC");
    		JButton MR=new JButton("MR");
    		JButton M0=new JButton("M+");
    		JButton M1=new JButton("M-");
    		JButton MS=new JButton("MS");
    		JButton M=new JButton("M");
    		panelN.add(MC);panelN.add(MR);panelN.add(M0);
    		panelN.add(M1);panelN.add(MS);panelN.add(M);
    		panel.add(panelN,BorderLayout.NORTH);
    		
    		CardLayout cardLayout=new CardLayout();
    		JPanel panelC=new JPanel();
    		panelC.setLayout(cardLayout);
    		
    		JPanel panel0=new JPanel();
    		panel0.setLayout(new GridLayout(6,4));
    		JButton[] standredButton=new JButton[24];
    		String str[]={ "%","√","x²","1/x",
    				"CE","C","×","/",
    				"7","8","9","*",
    				"4","5","6","-",
    				"1","2","3","+",
    				"±","0",".","="	
    		};
    		for(int i=0;i<standredButton.length;i++) { 
    			standredButton[i]=new JButton(str[i]);
    			String text=standredButton[i].getText();
    			standredButton[i].addActionListener(new ActionListener() { 
    				
    				@Override
    				public void actionPerformed(ActionEvent e) { 
    					// TODO Auto-generated method stub
    					if(text.equals("CE")||text.equals("C")) { 
    						textField.setText("");
    					}
    					else if(text.equals("=")) { 
    						String expression=textField.getText();
    						Calculate cal=new Calculate();
    						textField.setText(cal.evaluateExpression(expression)+"");
    					}
    					else if(text.equals("%")) { 
    						
    					}
    					else if(text.equals("√")) { 
    						result=Double.parseDouble(textField.getText());
    						result=Math.sqrt(result);
    						textField.setText(result+"");
    					}
    					else if(text.equals("x²")) { 
    						result=Double.parseDouble(textField.getText());
    						result*=result;
    						textField.setText(result+"");
    					}
    					else if(text.equals("1/x")) { 
    						result=Double.parseDouble(textField.getText());
    						result=1/result;
    						textField.setText(result+"");
    					}
    					else if(text.equals("±")) { 
    						if(count==0) { 
    							textField.setText(textField.getText()+"-");
    							count=1;
    						}
    						else { 
    							textField.setText(textField.getText()+"+");
    							count=0;
    						}
    					}
    					else if(text.equals("×")) { 
    						textField.setText(textField.getText().substring(0, textField.getText().length()-1));
    					}
    					else { 
    						textField.setText(textField.getText()+text);
    					}
    									
    				}
    				
    			}
    			
    			);
    			panel0.add(standredButton[i]);
    		}
    		panelC.add(panel0);
    		
    		JPanel panel1=new JPanel();
    		panel1.setLayout(new GridLayout(7,5));
    		JButton scienceButton[]=new JButton[35];
    		String str1[]= { 
    		"x²","x^y","sin","cos","tan",
    		"√","10^x","log","Exp","Mod",
    		"↑","CE","C","×","/",
    		"π","7","8","9","*",
    		"n!","4","5","6","-",
    		"±","1","2","3","+",
    		"(",")","0",".","="				
    		};
    		for(int i=0;i<str1.length;i++) { 
    			scienceButton[i]=new JButton(str1[i]);
    			//scienceButton[i].addActionListener();
    			panel1.add(scienceButton[i]);
    		}
    		panelC.add(panel1);
    			
    		panel.add(panelC,BorderLayout.CENTER);
    		
    		/* * 菜单 */
    		JMenuBar menuBar=new JMenuBar();
    		this.setJMenuBar(menuBar);
    		JMenu modelMenu=new JMenu("模式");
    		menuBar.add(modelMenu);
    		JMenuItem standred=new JMenuItem("标准");		
    		standred.addActionListener(new ActionListener() { 
    			@Override
    			public void actionPerformed(ActionEvent e) { 
    				// TODO Auto-generated method stub
    				cardLayout.first(panelC);
    			}		
    		});
    		modelMenu.add(standred);
    		JMenuItem science=new JMenuItem("科学");
    		science.addActionListener(new ActionListener() { 
    			@Override
    			public void actionPerformed(ActionEvent e) { 
    				// TODO Auto-generated method stub
    				cardLayout.last(panelC);
    			}			
    		});
    		modelMenu.add(science);
    		
    	}
    /* private class ButtonAction implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { // TODO Auto-generated method stub } } */
    }

*  Java计算带括号加减乘除表达式类的实现：

package Calculator;
    
    import java.util.*;
    
    /* *使用此类直接调用evaluateExpression方法即可，传入需计算的表达式，返回计算结果 */
    public class Calculate { 
        //这个函数的作用就是使用空格分割字符串，以便后面使用分割函数使得将字符串分割成数组
        public String insetBlanks(String s) { 
            String result = "";
            for (int i = 0; i < s.length(); i++) { 
                if (s.charAt(i) == '(' || s.charAt(i) == ')' ||
                        s.charAt(i) == '+' || s.charAt(i) == '-'
                        || s.charAt(i) == '*' || s.charAt(i) == '/')
                    result += " " + s.charAt(i) + " ";
                else
                    result += s.charAt(i);
            }
            return result;
        }
    
        public double evaluateExpression(String expression) { 
            Stack<Double> operandStack = new Stack<>();
            Stack<Character> operatorStack = new Stack<>();
            expression = insetBlanks(expression);
            String[] tokens = expression.split(" ");
            for (String token : tokens) { 
                if (token.length() == 0)   //如果是空格的话就继续循环，什么也不操作
                    continue;
                //如果是加减的话，因为加减的优先级最低，因此这里的只要遇到加减号，无论操作符栈中的是什么运算符都要运算
                else if (token.charAt(0) == '+' || token.charAt(0) == '-') { 
                    //当栈不是空的，并且栈中最上面的一个元素是加减乘除的人任意一个
                    while (!operatorStack.isEmpty()&&(operatorStack.peek() == '-' || operatorStack.peek() == '+' || operatorStack.peek() == '/' || operatorStack.peek() == '*')) { 
                        processAnOperator(operandStack, operatorStack);   //开始运算
                    }
                    operatorStack.push(token.charAt(0));   //运算完之后将当前的运算符入栈
                }
                //当前运算符是乘除的时候，因为优先级高于加减，因此要判断最上面的是否是乘除，如果是乘除就运算，否则的话直接入栈
                else if (token.charAt(0) == '*' || token.charAt(0) == '/') { 
                    while (!operatorStack.isEmpty()&&(operatorStack.peek() == '/' || operatorStack.peek() == '*')) { 
                        processAnOperator(operandStack, operatorStack);
                    }
                    operatorStack.push(token.charAt(0));   //将当前操作符入栈
                }
                //如果是左括号的话直接入栈，什么也不用操作,trim()函数是用来去除空格的，由于上面的分割操作可能会令操作符带有空格
                else if (token.trim().charAt(0) == '(') { 
                    operatorStack.push('(');
                }
                //如果是右括号的话，清除栈中的运算符直至左括号
                else if (token.trim().charAt(0) == ')') { 
                    while (operatorStack.peek() != '(') { 
                        processAnOperator(operandStack, operatorStack);    //开始运算
                    }
                    operatorStack.pop();   //这里的是运算完之后清除左括号
                }
                //这里如果是数字的话直接如数据的栈
                else { 
                    operandStack.push(Double.parseDouble(token));   //将数字字符串转换成数字然后压入栈中
                }
            }
            //最后当栈中不是空的时候继续运算，知道栈中为空即可
            while (!operatorStack.isEmpty()) { 
                processAnOperator(operandStack, operatorStack);
            }
            return operandStack.pop();    //此时数据栈中的数据就是运算的结果
        }
    
        //这个函数的作用就是处理栈中的两个数据，然后将栈中的两个数据运算之后将结果存储在栈中
        public void processAnOperator(Stack<Double> operandStack, Stack<Character> operatorStack) { 
            char op = operatorStack.pop();  //弹出一个操作符
            Double op1 = operandStack.pop();  //从存储数据的栈中弹出连个两个数用来和操作符op运算
            Double op2 = operandStack.pop();
            if (op == '+')  //如果操作符为+就执行加运算
                operandStack.push(op1 + op2);
            else if (op == '-')
                operandStack.push(op2 - op1);   //因为这个是栈的结构，自然是上面的数字是后面的，因此用op2-op1
            else if (op == '*')
                operandStack.push(op1 * op2);
            else if (op == '/')
                operandStack.push(op2 / op1);
        }
    }

*  主函数：

package Calculator;
    
    public class Main { 
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		Calculator calculator=new Calculator();
    	}
    
    }

# 设计实现展示 #

![Java实现的计算器][Java]

*  可以随意缩小放大界面，界面部件会跟随界面大小自适应调整。

# 其他功能 #

*  目前实现了标准型计算，科学型计算更加复杂，实现了界面，没有计算功能，后续可能会继续开发，敬请期待。

[20190601190542867.png]: /images/20210920/3bbf75ee840049b89c2577164b5969d9.png
[Java]: /images/20210920/9bfa1a5204d14a9d94bcee900ce63669.png