Java简单计算器

  1. import java.awt.BorderLayout;
  2. import java.awt.Color;
  3. import java.awt.GridLayout;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import javax.swing.JButton;
  7. import javax.swing.JFrame;
  8. import javax.swing.JPanel;
  9. import javax.swing.JTextField;
  10. /**
  11. * 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。 但还不支持键盘操作。
  12. */
  13. public class Calculator extends JFrame implements ActionListener {
  14. /** 计算器上的键的显示名字 */
  15. private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
  16. "*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
  17. /** 计算器上的功能键的显示名字 */
  18. private final String[] COMMAND = { "Backspace", "CE", "C" };
  19. /** 计算器左边的M的显示名字 */
  20. private final String[] M = { " ", "MC", "MR", "MS", "M+" };
  21. /** 计算器上键的按钮 */
  22. private JButton keys[] = new JButton[KEYS.length];
  23. /** 计算器上的功能键的按钮 */
  24. private JButton commands[] = new JButton[COMMAND.length];
  25. /** 计算器左边的M的按钮 */
  26. private JButton m[] = new JButton[M.length];
  27. /** 计算结果文本框 */
  28. private JTextField resultText = new JTextField("0");
  29. // 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
  30. private boolean firstDigit = true;
  31. // 计算的中间结果。
  32. private double resultNum = 0.0;
  33. // 当前运算的运算符
  34. private String operator = "=";
  35. // 操作是否合法
  36. private boolean operateValidFlag = true;
  37. public Calculator() {
  38. super ( ”MyCale“);
  39. init();
  40. // 设置计算器的背景颜色
  41. this.setBackground(Color.LIGHT_GRAY);
  42. this.setTitle("计算器");
  43. // 在屏幕(500, 300)坐标处显示计算器
  44. this.setLocation(500, 300);
  45. // 不许修改计算器的大小
  46. this.setResizable(false);   // this.setVisible(true);《表示可见》
  47. // 使计算器中各组件大小合适
  48. this.pack();
  49. }
  50. private void init() {
  51. // 文本框中的内容采用右对齐方式
  52. resultText.setHorizontalAlignment(JTextField.RIGHT);
  53. // 不允许修改结果文本框
  54. resultText.setEditable(false);
  55. // 设置文本框背景颜色为白色
  56. resultText.setBackground(Color.white);
  57. // 初始化计算器上键的按钮，将键放在一个画板内
  58. JPanel calckeysPanel = new JPanel();
  59. // 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  60. calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
  61. for (int i = 0; i < KEYS.length; i++) {
  62. keys[i] = new JButton(KEYS[i]);
  63. calckeysPanel.add(keys[i]);
  64. keys[i].setForeground(Color.blue);
  65. }
  66. // 运算符键用红色标示，其他键用蓝色表示
  67. keys[3].setForeground(Color.red);
  68. keys[8].setForeground(Color.red);
  69. keys[13].setForeground(Color.red);
  70. keys[18].setForeground(Color.red);
  71. keys[19].setForeground(Color.red);
  72. // 初始化功能键，都用红色标示。将功能键放在一个画板内
  73. JPanel commandsPanel = new JPanel();
  74. // 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  75. commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
  76. for (int i = 0; i < COMMAND.length; i++) {
  77. commands[i] = new JButton(COMMAND[i]);
  78. commandsPanel.add(commands[i]);
  79. commands[i].setForeground(Color.red);
  80. }
  81. // 初始化M键，用红色标示，将M键放在一个画板内
  82. JPanel calmsPanel = new JPanel();
  83. // 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
  84. calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
  85. for (int i = 0; i < M.length; i++) {
  86. m[i] = new JButton(M[i]);
  87. calmsPanel.add(m[i]);
  88. m[i].setForeground(Color.red);
  89. }
  90. // 下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
  91. // 将文本框放在北部，将calms画板放在计算器的西部。
  92. // 新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
  93. JPanel panel1 = new JPanel();
  94. // 画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
  95. panel1.setLayout(new BorderLayout(3, 3));
  96. panel1.add("North", commandsPanel);
  97. panel1.add("West", calckeysPanel);
  98. // 建立一个画板放文本框
  99. JPanel top = new JPanel();
  100. top.setLayout(new BorderLayout());
  101. top.add("Center", resultText);
  102. // 整体布局
  103. getContentPane().setLayout(new BorderLayout(3, 5));
  104. getContentPane().add("North", top);
  105. getContentPane().add("Center", panel1);
  106. getContentPane().add("West", calmsPanel);
  107. // 为各按钮添加事件侦听器
  108. // 都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
  109. for (int i = 0; i < KEYS.length; i++) {
  110. keys[i].addActionListener(this);
  111. }
  112. for (int i = 0; i < COMMAND.length; i++) {
  113. commands[i].addActionListener(this);
  114. }
  115. for (int i = 0; i < M.length; i++) {
  116. m[i].addActionListener(this);
  117. }
  118. }
  119. /**
  120. * 处理事件
  121. */
  122. public void actionPerformed(ActionEvent e) {
  123. // 获取事件源的标签
  124. String label = e.getActionCommand();
  125. if (label.equals(COMMAND[0])) {
  126. // 用户按了"Backspace"键
  127. handleBackspace();
  128. } else if (label.equals(COMMAND[1])) {
  129. // 用户按了"CE"键
  130. resultText.setText("0");
  131. } else if (label.equals(COMMAND[2])) {
  132. // 用户按了"C"键
  133. handleC();
  134. } else if ("0123456789.".indexOf(label) >= 0) {
  135. // 用户按了数字键或者小数点键
  136. handleNumber(label);
  137. // handlezero(zero);
  138. } else {
  139. // 用户按了运算符键
  140. handleOperator(label);
  141. }
  142. }
  143. private void handleBackspace() {
  144. String text = resultText.getText();
  145. int i = text.length();
  146. if (i > 0) {
  147. // 退格，将文本最后一个字符去掉
  148. text = text.substring(0, i - 1);
  149. if (text.length() == 0) {
  150. // 如果文本没有了内容，则初始化计算器的各种值
  151. resultText.setText("0");
  152. firstDigit = true;
  153. operator = "=";
  154. } else {
  155. // 显示新的文本
  156. resultText.setText(text);
  157. }
  158. }
  159. }
  160. private void handleNumber(String key) {
  161. if (firstDigit) {
  162. // 输入的第一个数字
  163. resultText.setText(key);
  164. } else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
  165. // 输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
  166. resultText.setText(resultText.getText() + ".");
  167. } else if (!key.equals(".")) {
  168. // 如果输入的不是小数点，则将数字附在结果文本框的后面
  169. resultText.setText(resultText.getText() + key);
  170. }
  171. // 以后输入的肯定不是第一个数字了
  172. firstDigit = false;
  173. }
  174. /**
  175. * 处理C键被按下的事件
  176. */
  177. private void handleC() {
  178. // 初始化计算器的各种值
  179. resultText.setText("0");
  180. firstDigit = true;
  181. operator = "=";
  182. }
  183. private void handleOperator(String key) {
  184. if (operator.equals("/")) {
  185. // 除法运算
  186. // 如果当前结果文本框中的值等于0
  187. if (getNumberFromText() == 0.0) {
  188. // 操作不合法
  189. operateValidFlag = false;
  190. resultText.setText("除数不能为零");
  191. } else {
  192. resultNum /= getNumberFromText();
  193. }
  194. } else if (operator.equals("1/x")) {
  195. // 倒数运算
  196. if (resultNum == 0.0) {
  197. // 操作不合法
  198. operateValidFlag = false;
  199. resultText.setText("零没有倒数");
  200. } else {
  201. resultNum = 1 / resultNum;
  202. }
  203. } else if (operator.equals("+")) {
  204. // 加法运算
  205. resultNum += getNumberFromText();
  206. } else if (operator.equals("-")) {
  207. // 减法运算
  208. resultNum -= getNumberFromText();
  209. } else if (operator.equals("*")) {
  210. // 乘法运算
  211. resultNum *= getNumberFromText();
  212. } else if (operator.equals("sqrt")) {
  213. // 平方根运算
  214. resultNum = Math.sqrt(resultNum);
  215. } else if (operator.equals("%")) {
  216. // 百分号运算，除以100
  217. resultNum = resultNum / 100;
  218. } else if (operator.equals("+/-")) {
  219. // 正数负数运算
  220. resultNum = resultNum * (-1);
  221. } else if (operator.equals("=")) {
  222. // 赋值运算
  223. resultNum = getNumberFromText();
  224. }
  225. if (operateValidFlag) {
  226. // 双精度浮点数的运算
  227. long t1;
  228. double t2;
  229. t1 = (long) resultNum;
  230. t2 = resultNum - t1;
  231. if (t2 == 0) {
  232. resultText.setText(String.valueOf(t1));
  233. } else {
  234. resultText.setText(String.valueOf(resultNum));
  235. }
  236. }
  237. // 运算符等于用户按的按钮
  238. operator = key;
  239. firstDigit = true;
  240. operateValidFlag = true;
  241. }
  242. private double getNumberFromText() {
  243. double result = 0;
  244. try {
  245. result = Double.valueOf(resultText.getText()).doubleValue();
  246. } catch (NumberFormatException e) {
  247. }
  248. return result;
  249. }
  250. public static void main(String args[]) {
  251. Calculator calculator1 = new Calculator();
  252. calculator1.setVisible(true);
  253. calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  254. }
  255. }
时间： 2024-10-13 20:24:26

Java简单计算器的相关文章

java简单计算器，只能鼠标点击数字

包含三个类 1.主类,包括计算器界面和每个键的功能实现calculator.java package com.bj.jsq; import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPanel; import java.awt.Dimension; import java.awt.TextField; import java.awt.Label; import java.awt.Button; impo

JAVA编写的简单计算器

package com.hellojava.practice.test; import java.awt.BorderLayout; import java.awt.GridLayout; import java.awt.Panel; import java.awt.TextField; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; impo

[Java.web]简单计算器

项目的  WebRoot 目录下的 calculator.jsp <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML> <html> <head> <title>计算结果</title> </head> <body> <jsp:us

简单计算器 java实现hdu1237

简单计算器 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 15190    Accepted Submission(s): 5184 Problem Description 读入一个只包含 +, -, *, / 的非负整数计算表达式,计算该表达式的值. Input 测试输入包含若干测试用例,每个测试用例占一行,每行不超过200个字符,

j2ee-JSP之简单计算器

来源韩顺平.j2ee视频实战教程jsp第1讲(下集) -------------------------------------------------------------------------------------------------------- 简单计算器,可以控制输入的数(仅第一个数)不能为空且不能为字符串 myCal.jsp代码 1 <!--这是计算器的界面 --> 2 <!-- 可以控制输入的数不能为空且不能为字符串 --> 3 <%@ page co

HDU1237 简单计算器 【栈】+【逆波兰式】

版本:1.0 日期:2014.5.17 2014.6.1 版权:© 2014 kince 转载注明出处 在介绍SwitchButton之前,先来看一下系统Button是如何实现的.源码如下: @RemoteView public class Button extends TextView { public Button(Context context) { this(context, null); } public Button(Context context, AttributeSet att

hdoj 1237 简单计算器

简单计算器 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 14512    Accepted Submission(s): 4920 Problem Description 读入一个只包含 +, -, *, / 的非负整数计算表达式,计算该表达式的值. Input 测试输入包含若干测试用例,每个测试用例占一行,每行不超过200个字符,整

菜鸟学Android编程——简单计算器《一》

菜鸟瞎搞,高手莫进 本人菜鸟一枚,最近在学Android编程,网上看了一些视频教程,于是想着平时手机上的计算器应该很简单,自己何不尝试着做一个呢? 于是就冒冒失失的开撸了. 简单计算器嘛,功能当然很少,加减乘除就可以. 第一步:设计布局文件 界面如下图: 由于刚开始学Android,对布局文件也不是很了解,边查边找,最后凑合着写好了布局文件. 注意事项:此布局文件用到了GridLayout布局,是在Android4.0以上才出现的(不知道谷歌有没有开发相应的包来适配4.0以下版本). 有关Gri

HDU 1237 简单计算器

简单计算器 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 12832    Accepted Submission(s): 4222 Problem Description 读入一个只包含 +, -, *, / 的非负整数计算表达式,计算该表达式的值. Input 测试输入包含若干测试用例,每个测试用例占一行,每行不超过200个字符,整