計算器小程序的改進

時間 2019-11-08

標籤計算器程序改進简体版

原文原文鏈接

軟件綜合實踐的第一次理解做業java

方法1,2參考連接 https://blog.csdn.net/Frank_Jay/article/details/52900089編程

方法3參考連接 https://blog.csdn.net/q982151756/article/details/80647663小程序

//簡易計算器小程序設計模式

閱讀過程：數組

1. 網上看到一個簡單的小程序，是關於輸入數字和加減乘除符號，能夠運算結果的安全

（閱讀後理解搜索的在代碼後註釋着）app

 1 //方法1：
 2 
 3 package jsj;
 4 
 5 import java.util.Scanner;
 6 
 7 /*
 8 
 9  * 《大話設計模式》中的計算器實現代碼
10  * https://blog.csdn.net/Frank_Jay/article/details/52900089
11 
12  * */
13 
14 public class Operation {     //Operation 類
15 
16     public static double GetResult(double numA, double numB, String opr) {//3個參數
17 
18         double result = 0d;//數值後面的d,表示是double類型數,好比 double b = 3.2d 
19 
20         switch (opr) {   //opr表示符號的選擇
21 
22             case "+":
23 
24                 result = numA + numB;
25 
26                 break;  
27 
28             case "-":
29 
30                 result = numA - numB;
31 
32                 break;
33 
34             case "*":
35 
36                 result = numA * numB;
37 
38                 break;
39 
40             case "/":
41 
42                 result = numA / numB;
43 
44                 break;
45 
46         }
47 
48         return result;
49 
50     }
51 
52  
53 
54     public static void main(String[] args) {
55 
56         System.out.println("請輸入數字A:");   //友好交互提示
57 
58         Scanner scan = new Scanner(System.in);
59         // 從鍵盤接收數據
60 
61         String strNumA = scan.nextLine(); // next方式接收字符串
62         //nextLine()方法返回的是Enter鍵以前沒有被讀取的全部字符，它是能夠獲得帶空格的字符串的
63         //next()方法在讀取內容時，會過濾掉有效字符前面的無效字符，
64         //對輸入有效字符以前遇到的空格鍵、Tab鍵或Enter鍵等結束符，next()方法會自動將其過濾掉
65         // 判斷是否還有輸入
66         System.out.println("請輸入運算符號(+、-、*、/):");
67 
68         String strOpr = scan.nextLine();
69 
70         System.out.println("請輸入數字B");
71 
72         String strNumB = scan.nextLine();
73 
74         String strResult = "";
75 
76         double Result = GetResult(Double.parseDouble(strNumA), Double.parseDouble(strNumB), strOpr);
77         //數字類型的String字符串轉換爲浮點數一般採用parseDouble()和valueOf()方法
78         /*
79          Double.parseDouble(java.lang.String)的參數只能是String，
80                       若是參數改成double類型提示「The method parseDouble(String) in the type Double is not applicable for the arguments (double)」錯誤。
81          Double.valueOf()的參數類型能夠是浮點型或者是字符串都可。
82         */
83 
84         strResult = String.valueOf(Result);
85 
86         System.out.println("結果爲"+strResult);
87 
88     }
89 
90  
91 
92 }

運行結果：ide

請輸入數字A:函數

11工具

請輸入運算符號(+、-、*、/):

請輸入數字B

結果爲88.0

2.閱讀過程2：以爲這樣的輸入太麻煩了，能不能直接輸入出結果呢？改進一下，不是單獨輸入，而是一塊兒輸入，直接出結果。

  1 //方法2
  2 
  3 package jsj;
  4 
  5 
  6 import java.util.Scanner;
  7 //java.util.Scanner 是 Java5 的新特徵，咱們能夠經過 Scanner 類來獲取用戶的輸入
  8 
  9 public class Calculator {
 10 
 11      public static void main(String[] args) {
 12 
 13          System.out.println("-----------------------------------");
 14 
 15          System.out.println("請輸入一個算術表達式，如：45*23");
 16 
 17          Scanner in = new Scanner(System.in);// 從鍵盤接收數據
 18       
 19          String str = in.nextLine();// nextline方式接收字符串
 20 
 21          StringBuffer buffer = new StringBuffer();
 22          /*當對字符串進行修改的時候，須要使用 StringBuffer 和 StringBuilder 類。 
 23                              和 String 類不一樣的是，StringBuffer 和 StringBuilder 類的對象可以被屢次的修改，而且不產生新的未使用對象。 
 24            StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不一樣在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。 
 25                               因爲 StringBuilder 相較於 StringBuffer 有速度優點，因此多數狀況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的狀況下，則必須使用 StringBuffer 類。 */
 26 
 27          StringBuffer buffer1 = new StringBuffer();
 28 
 29          char t = ' ';//默認初始化符號位，即「+-*/」
 30 
 31          for (int i = 0; i < str.length(); i++) {
 32 
 33              if (str.charAt(i) == '+' || str.charAt(i) == '-'
 34 
 35                      || str.charAt(i) == '*' || str.charAt(i) == '/') {
 36 
 37                  t = str.charAt(i);//把符號位賦值給t
 38                 //charAt()功能相似於數組，能夠把字符串看做是char類型的數組，它是把字符串拆分獲取其中的某個字符；返回指定位置的字符。 
 39                 // charAt(i)，i爲int類型，i從0開始。 
 40  
 41 
 42                  for (int j = i + 1; j < str.length(); j++) {
 43 
 44                      buffer1.append(str.charAt(j));
 45               //append() 方法在被選元素的結尾（仍然在內部）插入指定內容。
 46              /*Stringbuffer 有append()方法 
 47                Stringbuffer實際上是動態字符串數組 
 48              /*Stringbuffer 有append()方法 
 49                append()是往動態字符串數組添加，跟「xxxx」+「yyyy」至關那個‘+’號 
 50              /*Stringbuffer 有append()方法 
 51                                         跟String不一樣的是Stringbuffer是放一塊兒的 
 52                String1+String2 和Stringbuffer1.append("yyyy")雖然打印效果同樣，但在內存中表示卻不同 
 53                String1+String2 存在於不一樣的兩個地址內存 
 54                Stringbuffer1.append(Stringbuffer2)放在一塊兒 */
 55                      
 56                  }
 57 
 58                  break;
 59 
 60              } else {
 61 
 62                  buffer.append(str.charAt(i));
 63 
 64              }
 65 
 66          }
 67 
 68          String c = buffer.toString();//將buffer對象轉換成指定的字符編碼的字符串。
 69          /*好比：
 70           StringBuffer sb = new StringBuffer("abcd") ;
 71            sb.append("efg") ;
 72            String str = sb.toString() ;
 73            System.out.println(str) ; // out : "abcdefg" 
 74 
 75                  使用StringBuffer的toString()方法，能夠將StringBuffer轉換成String */
 76 
 77          String d = buffer1.toString();
 78 
 79          double a = Double.parseDouble(c);
 80 
 81          double b = Double.parseDouble(d);
 82         /* 
 83            Double.parseDouble方法是把數字類型的字符串，轉換成double類型
 84            Double.valueOf方法是把數字類型的字符串，轉換成Double類型
 85                               好比：字符 0.94
 86                              採用 valueOf  獲得的結果是 0.9400000000000001
 87                              而採用 parseDouble 獲得的結果是 0.94*/
 88 
 89          double sum = 0;
 90 
 91          if (t == '+') {
 92 
 93              sum = a + b;
 94 
 95          }
 96 
 97          if (t == '-') {
 98 
 99              sum = a - b;
100 
101          }
102 
103          if (t == '*') {
104 
105              sum = a * b;
106 
107          }
108 
109          if (t == '/') {
110 
111              sum = a / b;
112 
113          }
114 
115          System.out.println("程序運算...");
116 
117          System.out.println(c+t+d+"="+sum);
118 
119          System.out.print("-----------------------------------");
120 
121      }
122 
123 }

運行結果：

-----------------------------------

請輸入一個算術表達式，如：45*23

11*8

程序運算...

11*8=88.0

-----------------------------------

心得：

方法二是方法1的改進，更加符合人的邏輯思惟，相比於方法1更加快捷方便。

理解用戶需求：一個快捷的運算輸入（方法二），而不是一個個的拆分輸入（方法1），那麼想要更好地擴展使用，能夠用有界面結構的計算機小程序。

3.閱讀過程3：

仍是太麻煩了，能不能呈界面化，更加簡單些，不要是數據化，這樣會更加清晰！

  1 //方法3：
  2 
  3 package jsj;
  4 
  5 import javax.swing.*;
  6 import java.awt.*;
  7 import java.awt.event.ActionEvent;
  8 import java.awt.event.ActionListener;
  9 import java.util.Stack;
 10 
 11 class MyException extends Exception{
 12     public MyException() {
 13         super();
 14     }
 15     public MyException(String message) {
 16         super(message);
 17     }
 18 }
 19 
 20 public class MyCalculator extends JFrame{
 21     /*
 22      * 
 23      */
 24 
 25     private JTextField textField;               //輸入文本框
 26     private String input;                       //結果
 27     private String operator;                    //操做符
 28 
 29     public MyCalculator() {
 30         input = "";
 31         operator = "";
 32 
 33         JPanel panel = new JPanel();
 34         textField = new JTextField(30);
 35         textField.setEditable(false);                       //文本框禁止編輯
 36         textField.setHorizontalAlignment(JTextField.LEFT);
 37         //textField.setBounds(100, 100, 20, 20);            //在容器佈局爲空狀況下生效
 38         textField.setPreferredSize(new Dimension(200,30));//設置該組件的初始大小
 39 
 40         //將textField加入本JFrame中，佈局爲邊界佈局，位置爲north
 41         this.add(textField, BorderLayout.NORTH);
 42 
 43         String[] name= {"7","8","9","+","4","5","6","-","1","2","3","*","0","C","=","/"};
 44 
 45         //將這個panel的佈局設置爲網格佈局，有四行四列，行間距和列間距爲1
 46         panel.setLayout(new GridLayout(4,4,1,1));
 47 
 48         for(int i=0;i<name.length;i++) {
 49 
 50             JButton button = new JButton(name[i]);
 51 
 52             //設置按鈕的時間監聽
 53             button.addActionListener(new MyActionListener());
 54             //將按鈕加入到panel中
 55             panel.add(button);
 56         }
 57         //將panel加入到本JFrame中，佈局爲邊界佈局，位置爲centre
 58         this.add(panel,BorderLayout.CENTER);
 59     }
 60 
 61     class MyActionListener implements ActionListener{       //內部類實現按鈕響應
 62 
 63         @Override
 64         public void actionPerformed(ActionEvent e) {
 65             int cnt=0;
 66             String actionCommand = e.getActionCommand();     //獲取按鈕上的字符串
 67             if(actionCommand.equals("+") || actionCommand.equals("-") || actionCommand.equals("*")
 68                 || actionCommand.equals("/")) {
 69                 input += " " + actionCommand + " ";
 70             }
 71             else if(actionCommand.equals("C")) {                    //清除輸入
 72                 input = "";
 73             }
 74             else if(actionCommand.equals("=")) {                    //按下等號
 75                 try {
 76                     input+= "="+calculate(input);
 77                 } catch (MyException e1) {
 78                     if(e1.getMessage().equals("被除數不能爲0"))
 79                         input = e1.getMessage();
 80                     else
 81                         input = e1.getMessage();
 82                 }
 83                 textField.setText(input);
 84                 input="";
 85                 cnt = 1;
 86             }
 87             else
 88                 input += actionCommand;                         //按下數字
 89 
 90             //由於若是不按「=」按鈕cnt一直未0，因此能夠保證顯示輸入的數字和操做鍵
 91             if(cnt == 0)
 92                 textField.setText(input);
 93         }
 94     }
 95     //這裏須要藉助棧來完成表達式的計算，首先將字符串分割成字符串數組，
 96     //由中綴的定義知數組奇數位爲運算符（從第0位開始），偶數位爲操做數，
 97     // 所以可將偶數爲操做數進棧，碰見+(-)運算符，則將下一個數以正(負）的形式壓人棧中，
 98     // 碰見*或/運算符，則將棧頂元素出棧與數組後一元素進行計算，並將其結果從新壓入棧中，
 99     // 直至遍歷至數組最後一個元素。
100 
101     private String calculate(String input) throws MyException{       //計算函數
102         String[] comput = input.split(" ");
103         //System.out.println(input);
104         Stack<Double> stack = new Stack<>();
105         Double m = Double.parseDouble(comput[0]);
106         stack.push(m);                                      //第一個操做數入棧
107 
108         for(int i = 1; i < comput.length; i++) {
109             if(i%2==1) {
110                 if(comput[i].equals("+"))
111                     stack.push(Double.parseDouble(comput[i+1]));
112                 if(comput[i].equals("-"))
113                     stack.push(-Double.parseDouble(comput[i+1]));
114                 if(comput[i].equals("*")) {            //將前一個數出棧作乘法再入棧
115                     Double d = stack.peek();                //取棧頂元素
116                     stack.pop();
117                     stack.push(d*Double.parseDouble(comput[i+1]));
118                 }
119                 if(comput[i].equals("/")) {            //將前一個數出棧作乘法再入棧
120                     double help = Double.parseDouble(comput[i+1]);
121                     if(help == 0)
122                         throw new MyException("被除數不能爲0")；
123  //不會繼續執行該函數
124                     double d = stack.peek();
125                     stack.pop();
126                     stack.push(d/help);
127                 }
128             }
129         }
130 
131         double d = 0d;
132 
133         while(!stack.isEmpty()) {           //求和
134             d += stack.peek();
135             stack.pop();
136         }
137 
138         String result = String.valueOf(d);
139         return result;
140     }
141 
142     public static void main(String[] args) {
143         JFrame f = new MyCalculator();
144         f.setTitle(f.getClass().getSimpleName());
145         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
146         f.setBounds(400, 200, 500, 300);
147         f.setVisible(true);
148     }
149 }