devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java 计算器的实现（两种不同思路）_java 计算器的model怎么写

作者：Gausst松鼠会 | 2024-03-20 18:54:09

赞

踩

java 计算器的model怎么写

这几天java课上老师要我们实现一个计算器。由于刚开始学习java，其中界面显示部分的代码老师已经准备好了，并且整个程序是采用MVC（Model–view–controller，点击打开链接 ）的设计模式，我们要实现的只是其中的Model，即核心的算法模型。先看看用户界面（View部分）吧。


一、最初仅提供了基本用户界面的代码

为了让大家方便试验计算器程序，现把计算器的实现代码发上来。下面的是老师发布题目的代码。

     其中只有Calculator.java是MVC中的Model部分，这次也只需要修改这部分代码。其它部分提供了界面的布局、按钮等，不需要改变。

（1）最初的 Calculator类 定义

// Calculator.java
  1. // The core of the great calculator
  2. // Check the "TODO"s!!
  3.  
  4. class Calculator {
  5. 	String expression = "0";
  6.  
  7. 	// TODO: modify the method to return a proper expression 
  8. 	//	which will be shown in the screen of the calculator
  9. 	String getExpression() {
  10. 		return expression;
  11. 	}
  12.  
  13. 	// TODO: modify the method to handle the key press event
  14. 	void keyPressed(char key) {
  15. 		expression += key;
  16. 	}
  17.  
  18. 	// TODO: you can modify this method to print any debug
  19. 	//	information (It will be called by CalculatorCmd)
  20. 	void debugPrintStatus() {
  21. 		System.out.println("Expression = " + expression);
  22. 	}
  23. }

（2）计算器图形版 程序入口 

// CalculatorApp.java
  1. // Define entry point of the calculator application
  2.  
  3. class CalculatorApp {
  4. 	public static void main(String[] args) {
  5. 		CalculatorWindow mainwnd = new CalculatorWindow();
  6. 		CalculatorController control = new CalculatorController();
  7. 		mainwnd.setController(control);
  8. 		mainwnd.setVisible(true);
  9. 	}
  10. }

（3）计算器命令行版 程序入口 

// CalculatorCmd.java
  1. // A calculator with command line interface
  2.  
  3. import java.io.*;
  4.  
  5. public class CalculatorCmd {
  6. 	public static void main(String[] args) throws IOException {
  7. 		System.out.println("Welcome to use commoand line calculator.");
  8.  
  9. 		Calculator calculator = new Calculator();
  10.  
  11. 		while (true) {
  12. 			calculator.debugPrintStatus();
  13. 			System.out.println("\nEXP = " + calculator.getExpression());
  14. 			System.out.print("input: ");
  15. 			char c = (char)System.in.read();
  16. 			if (c == 'x' || c == 'X') break;
  17. 			calculator.keyPressed(c);
  18. 		}
  19.  
  20. 		System.out.println("\nBye.");		
  21. 	}
  22. }
（4）控制器（Control）部分，将按下的 按键key 移交给keypressed(char key)函数，这也是计算器需要编写的重点。 
// CalculatorController.java
  1. // The controller of the calculator application
  2.  
  3. import java.awt.event.*;
  4. import javax.swing.*;
  5.  
  6. class CalculatorController implements ActionListener {
  7.  
  8. 	Calculator calc = new Calculator();
  9. 	JLabel window;
  10.  
  11. 	public void actionPerformed(ActionEvent e) {
  12. 		char key = e.getActionCommand().charAt(0);
  13. 		calc.keyPressed(key);
  14. 		if (window!=null) {
  15. 			window.setText(calc.getExpression());
  16. 		}
  17. 	}
  18.  
  19. 	void setDisplayWindow(JLabel w) {
  20. 		window = w;
  21. 	}
  22. }
（5）计算器的窗口布局，有点繁琐，暂时可以不用细究。 
  1. // The window of the calculator application
  2. // Layout the buttons, and register the button action events
  3.  
  4. import java.awt.*;
  5. import javax.swing.*;
  6. import javax.swing.border.*;
  7. import java.awt.event.*;
  8.  
  9. class CalculatorWindow extends JFrame {
  10. 	JLabel disp;
  11. 	JButton cancelButton, equalButton, dotButton;
  12. 	JButton signButton, addButton, subButton, mulButton, divButton;
  13. 	JButton[] numButton;
  14.  
  15. 	CalculatorWindow() {
  16. 		this.setSize(400, 440);
  17. 		this.setResizable(false);
  18. 		this.setTitle("Java Calculator");
  19. 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  20. 		
  21. 		Container wnd = getContentPane();
  22. 		wnd.setLayout(null);
  23.  
  24. 		JPanel dispPanel = new JPanel();
  25. 		JPanel controlPanel = new JPanel();
  26. 		wnd.add(dispPanel);
  27. 		wnd.add(controlPanel);
  28. 		dispPanel.setBounds(0,0,400,60);
  29. 		controlPanel.setBounds(0,60,400,360);
  30.  
  31. 		dispPanel.setBorder(new LineBorder(Color.GRAY));
  32. 		disp = new JLabel("0");
  33. 		// disp.setBorder(new LineBorder(Color.RED));
  34. 		disp.setSize(new Dimension(380, 60));
  35. 		Font dispFont = new Font("Arial", Font.PLAIN, 24);
  36. 		disp.setFont(dispFont);
  37. 		disp.setHorizontalAlignment(SwingConstants.RIGHT);
  38. 		dispPanel.setLayout(null);
  39. 		dispPanel.add(disp);
  40. 		// dispPanel.setMinimumSize(new Dimension(400, 500));
  41.  
  42. 		GridBagLayout gridbag = new GridBagLayout();
  43. 		// controlPanel.setLayout(new GridLayout(4,4,10,20));
  44. 		controlPanel.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
  45. 		controlPanel.setLayout(gridbag);
  46. 		controlPanel.setBorder(new EmptyBorder(20,10,20,10));
  47.  
  48. 		cancelButton = new JButton("c");
  49. 		signButton = new JButton("+/-");
  50. 		addButton = new JButton("+");
  51. 		subButton = new JButton("-");
  52. 		mulButton = new JButton("*");
  53. 		divButton = new JButton("/");
  54. 		equalButton = new JButton("=");
  55. 		numButton = new JButton[10];
  56. 		for(int i=0; i<10; i++) {
  57. 			numButton[i] = new JButton(String.valueOf(i));
  58. 		}
  59. 		dotButton = new JButton(".");
  60.  
  61. 		GridBagConstraints c = new GridBagConstraints();
  62. 		c.insets = new Insets(3,2,3,2);
  63. 		c.fill = GridBagConstraints.BOTH;
  64. 	    c.weightx = 1.0;
  65. 	    c.weighty = 1.0;
  66. 	    gridbag.setConstraints(mulButton, c);
  67. 		controlPanel.add(mulButton);
  68. 	    gridbag.setConstraints(divButton, c);
  69. 		controlPanel.add(divButton);
  70. 	    gridbag.setConstraints(signButton, c);
  71. 		controlPanel.add(signButton);
  72. 		c.gridwidth = GridBagConstraints.REMAINDER;
  73. 	    gridbag.setConstraints(cancelButton, c);
  74. 		controlPanel.add(cancelButton);
  75.  
  76. 		c.gridwidth = 1;
  77. 	    gridbag.setConstraints(subButton, c);
  78. 		controlPanel.add(subButton);
  79. 	    gridbag.setConstraints(numButton[9], c);
  80. 		controlPanel.add(numButton[9]);
  81. 	    gridbag.setConstraints(numButton[8], c);
  82. 		controlPanel.add(numButton[8]);
  83. 		c.gridwidth = GridBagConstraints.REMAINDER;
  84. 	    gridbag.setConstraints(numButton[7], c);
  85. 		controlPanel.add(numButton[7]);
  86.  
  87. 		c.gridwidth = 1;
  88. 	    gridbag.setConstraints(addButton, c);
  89. 		controlPanel.add(addButton);
  90. 	    gridbag.setConstraints(numButton[6], c);
  91. 		controlPanel.add(numButton[6]);
  92. 	    gridbag.setConstraints(numButton[5], c);
  93. 		controlPanel.add(numButton[5]);
  94. 		c.gridwidth = GridBagConstraints.REMAINDER;
  95. 	    gridbag.setConstraints(numButton[4], c);
  96. 		controlPanel.add(numButton[4]);
  97.  
  98. 		c.gridwidth = 1;
  99. 		c.gridheight = 2;
  100. 	    gridbag.setConstraints(equalButton, c);
  101. 		controlPanel.add(equalButton);	
  102. 		c.gridheight = 1;
  103. 	    gridbag.setConstraints(numButton[3], c);
  104. 		controlPanel.add(numButton[3]);
  105. 	    gridbag.setConstraints(numButton[2], c);
  106. 		controlPanel.add(numButton[2]);
  107. 		c.gridwidth = GridBagConstraints.REMAINDER;
  108. 	    gridbag.setConstraints(numButton[1], c);
  109. 		controlPanel.add(numButton[1]);
  110.  
  111. 		c.gridwidth = 1;
  112. 		gridbag.setConstraints(dotButton, c);
  113. 		controlPanel.add(dotButton);
  114. 		c.gridwidth = GridBagConstraints.REMAINDER;
  115. 		gridbag.setConstraints(numButton[0], c);
  116. 		controlPanel.add(numButton[0]);
  117.  
  118. 		this.addWindowListener(new WindowAdapter() {
  119. 	       	public void windowOpened(WindowEvent e) {
  120. 	              equalButton.requestFocus();
  121. 	       	}
  122. 	    });
  123. 	}
  124. 	
  125. 	class CalculatorHotKey extends KeyAdapter {
  126. 		public void keyPressed(KeyEvent e) {
  127. 			char key = e.getKeyChar();
  128. 			if (key >= '0' && key <= '9') {
  129. 				numButton[key - '0'].doClick();
  130. 			} else switch(e.getKeyChar()) {
  131. 				case 'c':
  132. 				cancelButton.doClick();
  133. 				break;
  134. 				case '~':
  135. 				signButton.doClick();
  136. 				break;
  137. 				case '+':
  138. 				addButton.doClick();
  139. 				break;
  140. 				case '-':
  141. 				subButton.doClick();
  142. 				break;
  143. 				case '*':
  144. 				mulButton.doClick();
  145. 				break;
  146. 				case '/':
  147. 				divButton.doClick();
  148. 				break;
  149. 				case '=':
  150. 				equalButton.doClick();
  151. 				break;
  152. 				case '.':
  153. 				dotButton.doClick();
  154. 				break;
  155. 				case '\n':
  156. 				equalButton.doClick();
  157. 				break;
  158. 			}
  159. 		}
  160.  
  161. 	}
  162.  
  163. 	void setController(CalculatorController control) {
  164. 		control.setDisplayWindow(disp);
  165.  
  166. 		CalculatorHotKey keyMap = new CalculatorHotKey();
  167.  
  168. 		cancelButton.addKeyListener(keyMap);
  169. 		cancelButton.addActionListener(control);
  170. 		cancelButton.setActionCommand("c");
  171.  
  172. 		signButton.addKeyListener(keyMap);
  173. 		signButton.addActionListener(control);
  174. 		signButton.setActionCommand("~");
  175.  
  176. 		addButton.addKeyListener(keyMap);
  177. 		addButton.addActionListener(control);
  178. 		addButton.setActionCommand("+");
  179.  
  180. 		subButton.addKeyListener(keyMap);
  181. 		subButton.addActionListener(control);
  182. 		subButton.setActionCommand("-");
  183.  
  184. 		mulButton.addKeyListener(keyMap);
  185. 		mulButton.addActionListener(control);
  186. 		mulButton.setActionCommand("*");
  187.  
  188. 		divButton.addKeyListener(keyMap);
  189. 		divButton.addActionListener(control);
  190. 		divButton.setActionCommand("/");
  191.  
  192. 		equalButton.addKeyListener(keyMap);
  193. 		equalButton.addActionListener(control);
  194. 		equalButton.setActionCommand("=");
  195.  
  196. 		dotButton.addKeyListener(keyMap);
  197. 		dotButton.addActionListener(control);
  198. 		dotButton.setActionCommand(".");
  199.  
  200. 		for(int i=0; i<10; i++) {
  201. 			numButton[i].addKeyListener(keyMap);
  202. 			numButton[i].addActionListener(control);
  203. 			numButton[i].setActionCommand(String.valueOf(i));
  204. 		}
  205. 	}
  206. }


==========================================

二、采用状态机（State Machine）思路编写的计算器核心模型（Calculator.java）

       基于从老师课上演示得到的灵感，感觉整个计算器的行为表现得就像一个状态机（StateMachine）。上学期学EDA时，利用VHDL语言在FPGA硬件平台上完成许多任务时也是建立状态机模型来实现，我想那不妨就用状态机模型来指导整个程序的编写吧。我整理了一下计算器的各种状态，画了一张状态转移图。当然，或许还可以再设计出更简单的状态图。

       就像图例所示，每个状态有各自的状态编号st(i),i=1,2,..,5；初始状态为复位(st0)。

每个状态根据键盘不同的输入而跳转到不同的下一个状态，在每个状态中执行相应的操作。如下图：

      [1] 操作数置换：因为输入完第二操作数后，不是按等号，而是继续按下运算符，于是先把结果记作第1操作数，清空第二操作数，并继续进入输入运算符的状态。


在程序中，状态的编号是用枚举变量实现的，这个状态机的结构是在keyPressed(char key)函数中利用一个switch(c_state)实现的，其中c_state意味着当前状态（current state）。在每一个状态下会执行那个状态的服务函数fun_sti(),i=1,2,..,5；在这些函数内实现当前状态的任务以及状态跳转的控制。

       我自己觉得用这种思路去写程序，容易方便程序的不断“升级壮大”，因为每次我只需要仔细地完成某个状态的代码便可开始试运行，就算是某个状态的代码出错了，还不会影响到其它状态的执行，容易找出错误位置。还容易依此添加新的控制能力，就比如说要控制往屏幕上输出消息，可以拿当前状态为依据输出不同的消息：

完整的实现代码如下：

// Calculator.java
  1. // The core of the great calculator
  2. // Check the "TODO"s!!
  3.  
  4. class Calculator {
  5. 	private double result=0.0; 
  6. 	private char[] symbols={'+','-','*','/'};  // 定义将会使用到的符号
  7. 	private char symbol_use=' '; 	// 最近一次运算被选中的符号，默认为空
  8. 	private enum STATE {st0, st1, st2, st3, st4, st5}; // 状态图中使用的状态
  9. 	private STATE c_state= STATE.st1;	// 初始状态直接从 st1 开始好了
  10.  
  11. 	private OperaNum op_left = new OperaNum(),	// 定义左、右操作数
  12. 			 op_right = new OperaNum();
  13.  
  14. 	// 在屏幕上显示的内容，依据当前的不同状态来定。
  15. 	String getExpression() {
  16. 		switch(c_state){
  17. 			case st0:
  18. 			case st1:
  19. 				return op_left.STR_value();		
  20. 			case st2:
  21. 				return op_left.STR_value() + symbol_use;
  22. 			case st3:
  23. 				return op_left.STR_value() + symbol_use + op_right.STR_value();
  24. 			case st4:
  25. 				return "= " + result;
  26. 			default:
  27. 				return "0";
  28. 		}
  29. 	}
  30.  
  31. 	// 下面是处于各状态需要做的事情
  32. 	private void fun_st0(){
  33. 		op_left.setClear();
  34. 		op_right.setClear();
  35. 		result = 0.0;
  36. 		c_state = STATE.st1;
  37. 	}
  38.  
  39. 	private void fun_st1_basic(char key){
  40. 		if( (key>='0' && key<='9') || key=='.' || key=='~' ){
  41. 			op_left.pushDigital(key);
  42. 			c_state = STATE.st1;
  43. 		}
  44. 		else if( key=='=' ){
  45. 			// result = 
  46. 			symbol_use = '=';
  47. 			fun_result();
  48. 			c_state = STATE.st4;
  49. 		}
  50. 		else if( key=='c' ){ // 按下C键
  51. 			fun_st0();
  52. 			c_state = STATE.st0;
  53. 		}
  54. 		else { // 输入运算符号
  55. 		 fun_st2(key);
  56. 		 c_state = STATE.st2;
  57. 		}
  58. 	}
  59.  
  60. 	private void fun_st2(char key){
  61. 		if( key=='+' || key=='-' || key=='*' || key=='/'){
  62. 			symbol_use = key;
  63. 			c_state = STATE.st2;
  64. 		}
  65. 		else if( (key>='0' && key<='9') || key=='.' || key=='~' ){
  66. 			fun_st3(key);
  67. 			c_state = STATE.st3;
  68. 		}
  69. 	}
  70.  
  71. 	private void fun_st3(char key){
  72. 		if( (key>='0' && key<='9') || key=='.' || key=='~' ){
  73. 			op_right.pushDigital(key);
  74. 			c_state = STATE.st3;
  75. 		}
  76. 		else if( key=='=' ){
  77. 			// result = 
  78. 			fun_result();
  79. 			c_state = STATE.st4;
  80. 		}
  81. 		else if( key=='c' ){ // 按下C键
  82. 			fun_st0();
  83. 			c_state = STATE.st0;
  84. 		}
  85. 		else{
  86. 			c_state = STATE.st5; // 按下运算符号
  87. 			fun_st5(key);
  88. 		}
  89. 	}
  90.  
  91. 	void fun_st4(char key){ // 此时，已经显示出了结果
  92. 		if( (key>='0' && key<='9') || key=='.' || key=='~' ){
  93. 			fun_st0();
  94. 			op_left.pushDigital(key);
  95. 			c_state = STATE.st1;
  96. 		}
  97. 		else if( key=='+' || key=='-' || key=='*' || key=='/' ){ // 输入运算符号
  98. 			op_left.setValue(result);
  99. 			op_right.setClear();
  100. 			fun_st2(key);
  101. 			c_state = STATE.st2;
  102. 		}
  103. 	}
  104.  
  105. 	void fun_st5(char key){
  106. 		fun_result();
  107. 		op_left.setValue(result);
  108. 		op_right.setClear();
  109. 		fun_st2(key);
  110. 		c_state = STATE.st2;
  111. 	}
  112.  
  113. 	private void fun_result(){
  114. 		switch(symbol_use){
  115. 			case '+':
  116. 				result = op_left.value() + op_right.value();
  117. 			break;
  118. 			case '-':
  119. 				result = op_left.value() - op_right.value();
  120. 			break;
  121. 			case '*':
  122. 				result = op_left.value() * op_right.value();
  123. 			break;
  124. 			case '/':
  125. 				if( op_right.value()==0.0 )
  126. 					result = Double.POSITIVE_INFINITY;
  127. 				else
  128. 					result = op_left.value() / op_right.value();
  129. 			break;
  130. 			default: // 等号，或来自 st1 的直接按下等号
  131. 				result = op_left.value();
  132. 			break;
  133. 		}
  134. 	}
  135.  
  136. 	// 在此函数中设定状态机模型
  137. 	void keyPressed(char key) {
  138. 		//expression += key; 
  139. 		if(key=='c')
  140. 			c_state = STATE.st0; // 复位一下
  141.  
  142. 		switch(c_state){
  143. 			case st0: fun_st0(); // 初始状态，并且等待输入
  144. 			case st1: fun_st1_basic(key); break; // 输入左操作数
  145. 			// ===============
  146. 			case st2: fun_st2(key);	break;
  147. 			case st3: fun_st3(key);	break;
  148. 			case st4: fun_st4(key); break;
  149. 			case st5: fun_st5(key); break;
  150. 			default:
  151. 				fun_st0();
  152. 				c_state = STATE.st0;
  153. 			break;
  154. 		}
  155. 	}
  156.  
  157. 	// TODO: you can modify this method to print any debug
  158. 	//	information (It will be called by CalculatorCmd)
  159. 	void debugPrintStatus() {
  160. 		// System.out.println("Expression = " + expression);
  161. 		System.out.println( "c_state" + c_state );
  162. 	}
  163. }


上面还需要补充一点，为了方便进行左、右操作数的运算， 操作数单独提出来作为一种OperaNum类来实现，另写为OperaNum.java如下： 

  1. /* 操作数用类来实现，统一各种运算
  2.  --> 与数字有关的所有符号：【0-9】,【.】,【~】
  3.  */
  4. public class OperaNum{
  5. 	String expression="0";	// 操作数的字符串表达式
  6. 	private double v=0.0;	// 操作数的值
  7. 	private boolean SIGN=true; // true= pos, false= minus.
  8.  
  9. 	OperaNum(double v){
  10. 		setValue(v);
  11. 	}
  12.  
  13. 	OperaNum(){}
  14.  
  15. 	void pushDigital(char key){ // 用于实现状态图中的“输入操作数”
  16. 		// (1) 输入普通数字
  17. 		if( key>='0' && key<='9')
  18. 			if( expression.equals("0") ){ // 若字符串是初始状态0，再按0无反应
  19. 				if( key=='0')
  20. 					expression="0";
  21. 				else
  22. 					expression = String.valueOf(key);
  23. 			}
  24. 			else
  25. 				expression +=key;
  26.  
  27. 		if(key=='.')  // (2) 处理小数点
  28. 			pushDot(key);
  29. 		if(key=='~')  // (3) 处理符号
  30. 			SIGN = !SIGN;
  31.  
  32. 		v= value();
  33. 	}
  34.  
  35. 	void pushDot(char key){  // 帮助pushDigital()函数来输入小数点，这里要检查是否合乎规范
  36. 		if( expression.indexOf('.')<=0 ) // 若不成立，则表达式已经有小数点了
  37. 			expression += '.';
  38. 	}
  39.  
  40. 	void setValue(double init_num){ // 强制设定操作数，一般不用
  41. 		v = init_num;
  42. 		expression = String.valueOf(v);
  43. 	}
  44.  
  45. 	void setClear(){
  46. 		v = 0;
  47. 		expression = "0";
  48. 		SIGN = true;
  49. 	}
  50.  
  51. 	double value(){	// 返回当前操作数的值，还要根据是否加入了负号来决定取值
  52. 		v= Double.parseDouble(expression);
  53. 		return SIGN? v : (-1)*v;
  54. 	}
  55.  
  56. 	String STR_value(){ // 返回当前操作数的字符串表达式，
  57. 		return SIGN? expression : "(-"+expression+")";
  58. 	}
  59. }


三、用简单的if语句控制的计算器核心模型（Calculator.java）

换一种思路，你说要简单来看嘛，可以把整个运行就分作3种状态：输入第1个操作数（INPUT_1）、输入运算符(INPUT_OP)、输入第二个操作数(INPUT_2)、已经输出了结果(SHOW)。这可以在Calculator类的开头定义出几个状态来用： 

  1. 	private final int INPUT_1  = 1;
  2. 	private final int INPUT_OP = 2;
  3. 	private final int INPUT_2  = 3;
  4. 	private final int SHOW     = 4;
  5. 	private int INPUT_STATE = 1;  // 存放程序当前所处状态

当程序处在INPUT_1时，若按下了运算符，则进入INPUT_OP状态；

        在INPUT_OP状态时若按下了数字则进入了INPUT_2状态；之后若按下了等号则进入SHOW状态，并再自动进入INPUT_1状态。

在INPUT_2状态时，若按下了运算符，则先把当前结果记作第1操作数，清空第2操作数，并进入INPUT_OP状态。

实现代码如下：

// Calculator.java
  1. // The core of the great calculator
  2. // Check the "TODO"s!!
  3.  
  4. class MyNum{
  5. 	String expression="0";	// 操作数的字符串表达式
  6. 	private double value=0.0;	// 操作数的值
  7. 	boolean SIGN=true;	// 表示数字是正数还是负数
  8.  
  9. 	MyNum(){}
  10.  
  11. 	void pushDigital(char key){
  12. 		if( key>='0' && key<='9')	// 输入数字
  13. 			if( expression.equals("0") ){ // 若字符串是初始状态0，再按0无反应
  14. 				if( key=='0')
  15. 					expression="0";
  16. 				else
  17. 					expression = String.valueOf(key);
  18. 			}
  19. 			else
  20. 				expression += key;
  21. 		else if(key=='.') // 小数点
  22. 			pushDot(key);
  23. 		else if(key=='~')  // 正负数的转变
  24. 			SIGN = !SIGN;
  25. 	}
  26.  
  27. 	void pushDot(char key){  // 如果已经输入过小数点了，就不再输入
  28. 		if( expression.indexOf('.')<0 ) 
  29. 			expression += '.';
  30. 	}
  31.  
  32. 	void set(double num){ // 强制设定操作数，一般不用
  33. 		value = num;
  34. 		expression = String.valueOf(value);
  35. 	}
  36.  
  37. 	void clear(){
  38. 		value = 0;
  39. 		expression = "0";
  40. 		SIGN = true;
  41. 	}
  42.  
  43. 	double read_value(){	// 返回当前操作数的值，还要根据是否加入了负号来决定取值
  44. 		value = Double.parseDouble(expression);
  45. 		return SIGN? value : (-1)*value;
  46. 	}
  47.  
  48. 	String get_exp(){ // 返回当前操作数的字符串表达式，
  49. 		return SIGN? expression : " -"+expression;
  50. 	}
  51. }
  52.  
  53.  
  54. class Calculator {
  55. 	String expression = "0";
  56. 	char operator=' ';
  57. 	double result=0.0;
  58. 	MyNum left_op = new MyNum(),
  59. 		 right_op = new MyNum();
  60. 	private final int INPUT_1  = 1;
  61. 	private final int INPUT_OP = 2;
  62. 	private final int INPUT_2  = 3;
  63. 	private final int SHOW     = 4;
  64. 	private int INPUT_STATE = 1;  // 存放程序当前所处状态
  65.  
  66. 	// TODO: modify the method to return a proper expression 
  67. 	//	which will be shown in the screen of the calculator
  68. 	String getExpression() {
  69. 		if(INPUT_STATE==INPUT_1){
  70. 			expression = left_op.get_exp();
  71. 		}
  72. 		else if(INPUT_STATE==INPUT_OP){
  73. 			expression = "" + left_op.get_exp() + operator;
  74. 		}
  75. 		else if(INPUT_STATE==INPUT_2){
  76. 			expression = "" + left_op.get_exp() + operator + right_op.get_exp();
  77. 		}
  78. 		else if(INPUT_STATE==SHOW)
  79. 			expression = "= " + result;
  80.  
  81. 		return expression;
  82. 	}
  83.  
  84. 	// TODO: modify the method to handle the key press event
  85. 	void keyPressed(char key) {
  86. 		// expression += key;
  87. 		if(key=='c'){
  88. 			left_op.clear();
  89. 			right_op.clear();
  90. 			expression = "0";
  91. 			operator=' ';
  92. 			INPUT_STATE = INPUT_1;
  93. 		}
  94.  
  95. 		if( key>='0' && key<='9' || key=='.' || key=='~'){
  96. 			if (INPUT_STATE == SHOW) {
  97. 				left_op.clear();
  98. 				right_op.clear();
  99. 				expression = "0";
  100. 				operator=' ';
  101. 				INPUT_STATE = INPUT_1;
  102. 				left_op.pushDigital(key);				
  103. 			}
  104. 			else if(INPUT_STATE==INPUT_1){
  105. 				left_op.pushDigital(key);
  106. 			}
  107. 			else if (INPUT_STATE==INPUT_OP){
  108. 				INPUT_STATE = INPUT_2;
  109. 				right_op.pushDigital(key);
  110. 			}
  111. 			else if (INPUT_STATE==INPUT_2) {
  112. 				right_op.pushDigital(key);
  113. 			}
  114. 		}
  115.  
  116. 		if( key=='+' || key=='-' || key=='*' || key=='/' ){
  117. 			if(INPUT_STATE==INPUT_1)
  118. 				INPUT_STATE=INPUT_OP;
  119. 			else if(INPUT_STATE == SHOW){
  120. 				left_op.set(result);
  121. 				right_op.clear();
  122. 				INPUT_STATE=INPUT_OP;
  123. 			}
  124. 			// else if(INPUT_STATE)
  125. 			operator = key;
  126. 		}
  127.  
  128. 		if(key=='='){
  129. 			result = get_result();
  130. 			INPUT_STATE = SHOW;
  131. 		}
  132.  
  133. 	}
  134.  
  135. 	double get_result(){
  136. 		switch(operator){
  137. 			case '+': return left_op.read_value() + right_op.read_value();
  138. 			case '-': return left_op.read_value() - right_op.read_value();
  139. 			case '*': return left_op.read_value() * right_op.read_value();
  140. 			case '/':
  141. 				if(right_op.read_value()==0) return Double.POSITIVE_INFINITY;
  142. 				else return left_op.read_value() / right_op.read_value();
  143. 			default:  return left_op.read_value();
  144. 		}
  145.  
  146. 	}
  147.  
  148. 	// TODO: you can modify this method to print any debug
  149. 	//	information (It will be called by CalculatorCmd)
  150. 	void debugPrintStatus() {
  151. 		System.out.println("Expression = " + expression);
  152. 	}
  153. }






声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/275840
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号