JAVA计算器【源码】

1. 1. 
      
2. 1. 1. 
         
   2. import javax.microedition.midlet.*;  
   3. 
      
   4. import javax.microedition.lcdui.*;  
      1. 
         
3. 1. 1. 
         
   2. 
      
   3. 
      
   4. /**
   5. * 该类是应用程序的主类，控制应用程序的生命周期。
   6. */ 
   7. publicclass CalcMIDlet extends MIDlet implements CommandListener {  
   8.     //  
   9.     private CalcForm calcForm;  
   10.     private Command cmdExit = new Command("退出", Command.EXIT, 1);  
   11. 
       
   12.     publicvoid startApp() {  
   13.         Display display = Display.getDisplay(this);  
   14.         calcForm = new CalcForm();  
   15.         calcForm.addCommand(cmdExit);  
   16.         calcForm.setCommandListener(this);  
   17.         display.setCurrent(calcForm);  
   18.     }  
   19. 
       
   20.     publicvoid pauseApp() {  
   21.         //  
   22.     }  
   23. 
       
   24.     publicvoid destroyApp(boolean unconditional) {  
   25.         //  
   26.     }  
   27. 
       
   28.     publicvoid commandAction(Command cmd, Displayable d) {  
   29.         if(cmd == cmdExit) {  
   30.             notifyDestroyed();  
   31.         }  
   32.     }  
   33. }  
   34. 
       
       1. 
          

4. Java代码

5. 1. 1. 
         
   2. import javax.microedition.lcdui.*;  
   3. 
      
   4. /**
   5. * 该类描述了计算器。
   6. * 实现了计算器的界面，及加、减、乘、除等计算功能。
   7. */ 
   8. publicclass CalcForm extends Form implements CalcKeyboardListener { //  
   9.     private CalcScreen showArea;    //计算器的显示区  
   10.     private CalcKeyboard ckeyboard; //计算器键盘  
   11. 
       
   12.     privateboolean hasNewOperand = false;  //有新的操作数  
   13.     privateboolean numInputing = false;  
   14.     privatedouble acc = 0.0;  //累加器  
   15.     private String operator = "";    //运算符  
   16.     privatedouble operand = 0.0;   //操作数  
   17. 
       
   18.     public CalcForm() {  
   19.         super("计算器");  
   20.         showArea = new CalcScreen();            //创建计算器的显示区对象  
   21.         ckeyboard = new CalcKeyboard(4, 5);     //创建计算器的键盘  
   22.         ckeyboard.setCalcKeyboardListener(this);    //  
   23. 
       
   24.         //布局  
   25.         showArea.setLayout(Item.LAYOUT_2|Item.LAYOUT_CENTER|Item.LAYOUT_NEWLINE_AFTER);  
   26.         append(showArea);  
   27.         append(new Spacer(this.getWidth(), 5));  
   28.         ckeyboard.setLayout(Item.LAYOUT_2|Item.LAYOUT_CENTER);  
   29.         append(ckeyboard);  
   30. 
       
   31.         reset();  
   32.     }  
   33. 
       
   34.     //按钮单击事件处理方法  
   35.     //如果设备支持触摸屏功能，当用户使用笔在按钮上单击后，  
   36.     //注册在键盘上的监视器将调用下面的方法，对单击事件进行处理。  
   37.     publicvoid actionPerformmed(CalcKeyboard btn, String symbol) {  
   38.         if(symbol == CalcKeyboard.NUM_ZERO || symbol == CalcKeyboard.NUM_ONE || symbol == CalcKeyboard.NUM_TWO ||  
   39.             symbol == CalcKeyboard.NUM_THREE ||symbol == CalcKeyboard.NUM_FOUR ||symbol == CalcKeyboard.NUM_FIVE ||  
   40.             symbol == CalcKeyboard.NUM_SIX ||symbol == CalcKeyboard.NUM_SEVEN ||symbol == CalcKeyboard.NUM_EIGHT ||  
   41.             symbol == CalcKeyboard.NUM_NINE ) {  
   42.             //  
   43.             inputNum(symbol);  
   44.         }  
   45.         elseif(symbol == CalcKeyboard.SYMBOL_DOT   
   46.                 && showArea.getText().indexOf(CalcKeyboard.SYMBOL_DOT) == -1) {  
   47.             //  
   48.             inputNum(symbol);  
   49.         }  
   50.         elseif(symbol == CalcKeyboard.BACKSPACE) {  
   51.             String text = showArea.getText();  
   52.             if(text.length() > 0) {  
   53.                 text = text.substring(0, text.length()-1);  
   54.                 showArea.setText(text);  
   55.             }  
   56.         }  
   57.         elseif(symbol == CalcKeyboard.CE) {  
   58.             showArea.setText("0.");  
   59.         }  
   60.         elseif(symbol == CalcKeyboard.C) {  
   61.             //计算器归零  
   62.             reset();  
   63.         }  
   64.         elseif(symbol == CalcKeyboard.ADD || symbol == CalcKeyboard.MINUS ||   
   65.                     symbol == CalcKeyboard.MULT || symbol == CalcKeyboard.DIVIDE ||  
   66.                     symbol == CalcKeyboard.EQUALS) {  
   67.             //  
   68.             numInputing = false;  
   69.             String s = showArea.getText();  
   70.             double d = Double.parseDouble(s);  
   71.             jisuan(d, symbol);  
   72.             showArea.setText(String.valueOf(acc));  
   73.         }  
   74.         elseif(symbol == CalcKeyboard.SYMBOL_MINUS) {  
   75.             String str = showArea.getText();  
   76.             if(str.charAt(0) == '-') {  
   77.                 showArea.setText(str.substring(1, str.length()));  
   78.             }  
   79.             else {  
   80.                 showArea.setText("-" + str);  
   81.             }  
   82.         }  
   83.     }  
   84. 
       
   85.     privatevoid jisuan(double exp, String oper) {  
   86.         if(operator.equals("")) {  
   87.             acc = exp;  
   88.             operand = exp;  
   89.         }  
   90.         else {  
   91.             if(hasNewOperand) { //新的操作数  
   92.                 operand = exp;  
   93.                 if(operator.equals(CalcKeyboard.ADD)) {  
   94.                     acc += operand;  
   95.                 }  
   96.                 elseif(operator.equals(CalcKeyboard.MINUS)) {  
   97.                     acc -= operand;  
   98.                 }  
   99.                 elseif(operator.equals(CalcKeyboard.MULT)) {  
   100.                     acc *= operand;  
   101.                 }  
   102.                 elseif(operator.equals(CalcKeyboard.DIVIDE)) {  
   103.                     acc /= operand;  
   104.                 }  
   105. 
        
   106.             }  
   107.             else {  
   108.                 if(oper.equals(CalcKeyboard.EQUALS)) {  
   109.                     if(operator.equals(CalcKeyboard.ADD)) {  
   110.                         acc += operand;  
   111.                     }  
   112.                     elseif(operator.equals(CalcKeyboard.MINUS)) {  
   113.                         acc -= operand;  
   114.                     }  
   115.                     elseif(operator.equals(CalcKeyboard.MULT)) {  
   116.                         acc *= operand;  
   117.                     }  
   118.                     elseif(operator.equals(CalcKeyboard.DIVIDE)) {  
   119.                         acc /= operand;  
   120.                     }  
   121.                     if(!oper.equals(CalcKeyboard.EQUALS)) {  
   122.                         operator = oper;  
   123.                     }  
   124.                 }  
   125.             }  
   126.         }  
   127.         if(!oper.equals(CalcKeyboard.EQUALS)) {  
   128.             operator = oper;  
   129.         }  
   130.         hasNewOperand = false;  
   131.     }  
   132. 
        
   133.     privatevoid reset() {  
   134.         hasNewOperand = false;  
   135.         numInputing = false;  
   136.         acc = 0.0;  
   137.         operator = "";  
   138.         showArea.setText("0.");  
   139.     }  
   140. 
        
   141.     privatevoid inputNum(String str) {  
   142.         if(numInputing) {  
   143.             showArea.setText(showArea.getText() + str);  
   144.         }  
   145.         else {  
   146.             showArea.setText(str);  
   147.             numInputing = true;  
   148.         }  
   149.         hasNewOperand = true;  
   150.     }  
   151. }  
   152. 
        
        1. 
           

6. Java代码

7. 1. 1. 
         
   2. import javax.microedition.lcdui.*;  
   3. 
      
   4. /**
   5. * 该类描述了计算器键盘。提供了直观的图形用户界面，该类支持触摸屏功能。
   6. */ 
   7. publicclass CalcKeyboard extends CustomItem {  
   8.     publicstaticfinal String BACKSPACE = "<-";  
   9.     publicstaticfinal String CE = "CE";  
   10.     publicstaticfinal String C = "C";  
   11.     publicstaticfinal String SYMBOL_MINUS = "+/-";  
   12.     publicstaticfinal String NUM_ZERO = "0";  
   13.     publicstaticfinal String NUM_ONE = "1";  
   14.     publicstaticfinal String NUM_TWO = "2";  
   15.     publicstaticfinal String NUM_THREE = "3";  
   16.     publicstaticfinal String NUM_FOUR = "4";  
   17.     publicstaticfinal String NUM_FIVE = "5";  
   18.     publicstaticfinal String NUM_SIX = "6";  
   19.     publicstaticfinal String NUM_SEVEN = "7";  
   20.     publicstaticfinal String NUM_EIGHT = "8";  
   21.     publicstaticfinal String NUM_NINE = "9";  
   22.     publicstaticfinal String SYMBOL_DOT = ".";  
   23.     publicstaticfinal String ADD = "+";  
   24.     publicstaticfinal String MINUS = "-";  
   25.     publicstaticfinal String MULT = "*";  
   26.     publicstaticfinal String DIVIDE = "/";  
   27.     publicstaticfinal String EQUALS = "=";  
   28. 
       
   29.     privatestaticfinalint PRESSED = 0;  
   30.     privatestaticfinalint RELEASED = 1;  
   31. 
       
   32.     private CalcKeyboardListener ckListener;    //指针动作监视器  
   33.     private Font textFont;  
   34.     privateint col;    //列  
   35.     privateint row;    //行  
   36.     privateint btnWidth;   //按键宽  
   37.     privateint btnHeight;  //按键高  
   38.     privateint hSpace = 4; //按键水平间距  
   39.     privateint vSpace = 4; //按键垂直间距  
   40. 
       
   41.     privateint keyState = RELEASED;  
   42. 
       
   43.     private String[] keyLabel = {  
   44.         BACKSPACE, CE, C, SYMBOL_MINUS,   
   45.         NUM_SEVEN, NUM_EIGHT, NUM_NINE, DIVIDE,  
   46.         NUM_FOUR, NUM_FIVE, NUM_SIX, MULT,  
   47.         NUM_ONE, NUM_TWO, NUM_THREE, MINUS,  
   48.         NUM_ZERO, SYMBOL_DOT, EQUALS, ADD  
   49.     };  
   50. 
       
   51.     public CalcKeyboard(int col, int row) {  
   52.         super(null);  
   53.         textFont = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_LARGE);  
   54.         this.col = col;  
   55.         this.row = row;  
   56.         btnHeight = textFont.getHeight() + 4;  
   57.         btnWidth = btnHeight + 10;  
   58.     }  
   59. 
       
   60.     protectedint getMinContentHeight() {  
   61.         return row * (btnHeight + vSpace) - vSpace;  
   62.     }  
   63. 
       
   64.     protectedint getMinContentWidth() {  
   65.         return col * (btnWidth + hSpace) - hSpace;  
   66.     }  
   67. 
       
   68.     protectedint getPrefContentHeight(int width) {  
   69.         return getMinContentHeight();  
   70.     }  
   71. 
       
   72.     protectedint getPrefContentWidth(int height) {  
   73.         return getMinContentWidth();  
   74.     }  
   75. 
       
   76.     protectedvoid paint(Graphics g, int w, int h) {  
   77.         for(int i=0; i<keyLabel.length; i++) {  
   78.             drawButton(g, keyLabel[i], i%col * (btnWidth+hSpace), i/col*(btnHeight+vSpace), btnWidth, btnHeight);  
   79.         }  
   80.     }  
   81. 
       
   82.     privatevoid drawButton(Graphics g, String str, int x, int y, int w, int h) {  
   83.         g.setColor(160, 160, 255);  
   84.         g.drawRect(x, y, w-1, h-1);  
   85.         if(keyState == RELEASED) {  
   86.             g.setColor(240, 240, 255);  
   87.         }  
   88.         elseif(keyState == PRESSED) {  
   89.             g.setColor(210, 210, 255);  
   90.         }  
   91.         g.fillRect(x+2, y+2, w-4, h-4);  
   92. 
       
   93.         g.setColor(0, 0, 0);  
   94.         g.setFont(textFont);  
   95.         g.drawString(str, x+w/2, y+h, Graphics.BOTTOM|Graphics.HCENTER);  
   96.     }  
   97. 
       
   98.     privateint getIndex(int x, int y) {  
   99.         int j = x / (btnWidth+hSpace);  
   100.         int i = y / (btnHeight+vSpace);  
   101. 
        
   102.         return (col*i)+j;  
   103.     }  
   104. 
        
   105.     //指针事件处理方法  
   106.     //如果当前设备支持触摸屏功能,当用户使用笔在屏幕上按下时,  
   107.     //系统将调用该方法。  
   108.     protectedvoid pointerPressed(int x, int y) {  
   109.         keyState = PRESSED;  
   110.         int ax = x - x % (btnWidth+hSpace);  
   111.         int ay = y - y % (btnHeight+vSpace);  
   112.         repaint(ax, ay, btnWidth, btnHeight);  
   113.     }   
   114. 
        
   115.     //指针事件处理方法  
   116.     //如果当前设备支持触摸屏功能,当用户使用笔在屏幕上按下,然后释放时,  
   117.     //系统将调用该方法。  
   118.     protectedvoid pointerReleased(int x, int y) {  
   119.         keyState = RELEASED;  
   120.         int ax = x - x % (btnWidth+hSpace);  
   121.         int ay = y - y % (btnHeight+vSpace);  
   122.         repaint(ax, ay, btnWidth, btnHeight);  
   123.         if(ckListener != null) {  
   124.             int index = getIndex(x, y);  
   125.             ckListener.actionPerformmed(this, keyLabel[index]);  
   126.         }  
   127.     }  
   128. 
        
   129.     //为当前计算器键盘设置监视器  
   130.     publicvoid setCalcKeyboardListener(CalcKeyboardListener ckListener) {  
   131.         this.ckListener = ckListener;  
   132.     }  
   133. }  
   134. 
        
   135. 
        
   136. /**
   137. * 该接口描述了计算器键盘的监视器，定义了计算器键盘按钮单击动作
   138. * 的处理方法。
   139. */ 
   140. publicinterface CalcKeyboardListener {  
   141.     //指针单击动作的处理方法。  
   142.     //如果设备支持触摸屏功能，当用户使用笔单击屏幕上计算盘键盘上的按钮  
   143.     //时，监视该键盘的监视器将回调该方法，处理单击动作。  
   144.     //参数ck表示被监视的计算器键盘，symbol表示键盘上的按键。  
   145.     publicvoid actionPerformmed(CalcKeyboard ck, String symbol);  
   146. }  
   147. 
        
        1. 
           

8. Java代码

9. 1. 1. 
         
   2. import javax.microedition.lcdui.*;  
   3. 
      
   4. /**
   5. * 该类描述了计算器的显示区，用于显示输入的操作数及计算结果。
   6. */ 
   7. publicclass CalcScreen extends CustomItem {  
   8.     private String text;  
   9.     private Font showFont;  
   10. 
       
   11.     public CalcScreen() {  
   12.         super(null);  
   13.         showFont = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_LARGE);  
   14.         text = "";  
   15.     }  
   16. 
       
   17.     protectedint getMinContentHeight() {  
   18.         return showFont.getHeight() + 4;  
   19.     }  
   20. 
       
   21.     protectedint getMinContentWidth() {  
   22.         return showFont.stringWidth("012345678901234.-") + 4;  
   23.     }  
   24. 
       
   25.     protectedint getPrefContentHeight(int width) {  
   26.         return getMinContentHeight();  
   27.     }  
   28. 
       
   29.     protectedint getPrefContentWidth(int height) {  
   30.         return 150;  
   31.     }  
   32. 
       
   33.     protectedvoid paint(Graphics g, int w, int h) {  
   34.         g.setColor(160, 160, 255);  
   35.         g.drawRect(0, 0, w-1, h-1);  
   36.         g.setColor(210, 210, 255);  
   37.         g.drawRect(2, 2, w-5, h-5);  
   38. 
       
   39.         g.setColor(0, 0, 0);  
   40.         g.setFont(showFont);  
   41.         g.drawString(text, w-10, h-3, Graphics.BOTTOM|Graphics.RIGHT);  
   42.     }  
   43. 
       
   44.     publicvoid setText(String text) {  
   45.         this.text = text;  
   46.         repaint();  
   47.     }  
   48. 
       
   49.     public String getText() {  
   50.         return text;  
   51.     }  
   52. }
       1.