java计算器程序设计报告(含源代码)Word版

合集下载

java简易计算器实训报告(一)

java简易计算器实训报告(一)Java简易计算器实训报告实训目的通过编写一个简易的Java计算器，深入了解Java基础语法，并掌握对象的属性和行为。

实训过程本次实训采用Eclipse编写Java程序，具体过程如下：1.首先创建一个名为“Calaulator”的Java项目，再在其中创建一个名为“Calaulator”的类。

2.在Calaulator类中定义一个名为“calculate”的方法，此方法接收3个参数：一个char类型的操作符，两个double类型的操作数，返回值为double类型。

3.在方法体中根据传入的操作符进行相应的加、减、乘、除运算。

4.创建一个主函数，在其中调用calculate方法并输出结果。

实训收获通过本次实训，我掌握了Java的基础语法，并深入了解了对象的属性和行为。

同时，我还学会了如何使用Eclipse编写Java程序，提高了自己的编程水平。

实训总结Java语言作为一种强大而稳定的编程语言，具有广泛的应用场景。

通过本次实训，我深刻认识到Java的重要性，并希望能够在以后的学习中不断探索Java语言的更多使用方法。

实训反思在实训过程中，我发现自己对Java的基础语法了解不够深入，导致编写代码时遇到一些困难，需要不断查阅相关资料。

同时，在调试代码时也遇到了许多问题，发现自己对IDE的使用不够熟练，需要更多的实践和学习。

实训展望通过本次实训，我已经初步掌握了Java的基础语法和编程思想，但我认为这只是一个开始。

我需要不断地练习，深入了解Java的各种特性，将其应用到实际开发中。

未来，我希望能够成为一名优秀的Java工程师，为社会做出自己的贡献。

结语本次Java简易计算器实训让我收获颇丰，不仅加深了对Java的认识，也增强了自己的编程实践能力。

希望今后能够在Java的学习和实践中不断提高自己，取得更好的成果。

java计算器设计实验报告

java计算器设计实验报告《Java计算器设计实验报告》摘要：本实验报告基于Java语言，设计了一个简单的计算器。

通过使用面向对象的编程方法，实现了基本的加、减、乘、除运算，并且实现了用户界面的交互操作。

本实验报告详细介绍了计算器的设计思路、实现过程和代码结构，并对实验结果进行了分析和总结。

1. 引言计算器是人们日常生活中常用的工具之一，它能够帮助人们进行简单的数学运算。

随着计算器的普及和发展，计算器的功能也越来越丰富，例如科学计算器、金融计算器等。

本实验旨在通过使用Java语言，设计一个简单的计算器，以加深对面向对象编程的理解和应用。

2. 设计思路在设计计算器时，首先需要确定计算器的功能需求，包括加法、减法、乘法、除法等基本运算。

其次，需要考虑用户界面的设计，使用户能够方便地输入数字和选择运算符。

最后，需要考虑计算器的实现方式，包括数据结构的选择、算法的设计等。

3. 实现过程在本实验中，我们使用Java语言和Swing库来实现计算器的设计。

首先，我们创建一个Calculator类来处理计算器的逻辑操作，包括加法、减法、乘法、除法等运算。

然后，我们创建一个CalculatorUI类来处理用户界面的设计，包括数字按钮、运算符按钮和显示屏的设计。

最后，我们将Calculator类和CalculatorUI类进行整合，实现一个完整的计算器。

4. 代码结构以下是计算器的主要代码结构：Calculator类：- add(double a, double b)：加法运算- subtract(double a, double b)：减法运算- multiply(double a, double b)：乘法运算- divide(double a, double b)：除法运算CalculatorUI类：- createNumberButton(int number)：创建数字按钮- createOperatorButton(String operator)：创建运算符按钮- createDisplayScreen()：创建显示屏Main类：- main(String[] args)：主函数，启动计算器界面5. 实验结果分析通过实验，我们成功地实现了一个简单的计算器，用户能够输入数字并进行加、减、乘、除等运算。

用JAVA编写的计算器程序的设计报告

目录目录 (1)1 需求分析 (1)1.1 计算器的基本功能： (1)1.1.1 加法运算：用数字按钮和“+”按钮进行运算； (1)1.1.2 减法运算：用数字按钮和“-”按钮进行运算； (1)1.1.3 乘法运算：用数字按钮和“*”按钮进行运算； (1)1.1.4 除法运算：用数字按钮和“/”按钮进行运算； (1)1.2 退格键和清零键: 用”Backspace”和”C”按钮实现; (1)1.3 计算器的科学计算方法： (1)1.3.1 开方：用数字按钮和“Sqrt”按钮进行运算； (1)1.3.2 百分比：用数字按钮和“%”按钮进行运算； (1)1.3.3 求倒数：用数字按钮和“1/x”按钮进行运算； (1)2 设计 (2)2.1 用户界面设计 (2)2.1.1 该计算器程序的设计：用户界面包括Swing组件,不过程序中大都使用的是AWT组件. import java.awt.*; (2)2.1.2 在AWT组件, (2)2.1.3 这个界面设计中包含了两个接口,单击事件监听器接ActionListener口和键盘事件监听器接口(KeyListener). (4)2.1.4 程序设计中,使用了布局管理: (4)2.2 概要设计 (4)2.2.1 Calculator类中的类名是Calculator.它的功能是使用图形用户来实现计算器的界面设计和运算功能以及一些科学运算方法. (4)2.2.2 main主类.中调用了cal.display来实现计算器的功能 . (4)3 实现 (4)4 测试 (16)4.1 实现加法运算：4+12=16 (17)4.2 实现减法运算：22-11=11 (17)4.3 实现乘法运算：3*9=27 (18)4.4 实现除法运算：64/32=2 (18)4.5 用”C’实现清零功能: (19)4.6 用”Backspace”实现退格功能: (20)4.7 求倒数:1/4=0.25 (20)5 总结和体会............................................... 错误!未定义书签。

java课设计算器报告

java课设计算器报告随着计算机的快速发展，计算机科学正在成为21世纪最重要的学科之一。

同时，作为计算机科学的一部分，Java语言也正在发展壮大。

因此，Java的课程也随之增加，如程序设计，软件工程，数据库，机器学习等等。

作为一名Java专业的学生，在学习课程的同时，我也做了一次课程设计，即实现一个Java算法计算器，如加，减，乘，除以及整数，小数，次方，根号等功能。

首先，我们需要完成一些准备工作，即使用Java语言实现功能。

为了实现上述功能，我们按照以下步骤进行：首先，使用if..else 语句来判断输入是操作数还是操作符；其次，使用switch语句来实现操作；最后，使用System.out.print()函数将结果显示在控制台中。

在实现完上述步骤之后，算法计算器功能就完成了，我们可以开始进行测试。

在测试过程中，我们输入各种操作数和操作符，并检查计算器是否能够正确计算出结果，并且检查算法是否能够实现各种功能，如加减乘除等。

我们最终实现了加减乘除，整数，小数，次方，根号等功能，在测试中结果都正确，证明算法可以实现预期的功能。

最后，总结一下这次实现Java算法计算器的过程：首先，我们使用if..else语句和switch语句来实现功能；其次，我们使用System.out.print()函数来显示结果；最后，在测试中结果都正确，证明算法可以实现预期的功能。

本次实验表明，当我们使用编程语言实现算法时，可以正确地实现我们预期的功能。

本次实验也使我对Java语言有了更深的理解，并且也使我对算法的原理有了更深的认识。

综上所述，我们实现的Java算法计算器可以满足本次实验的需要，具有正确的功能，并且在实验过程中，我们也对算法和Java语言都有了更深的了解。

java计算器设计实验报告

java计算器设计实验报告Java计算器设计实验报告引言：计算器是人们日常生活中常见的工具之一，它能够进行基本的数学运算，方便人们进行快速计算。

本实验旨在通过使用Java编程语言设计一个简单的计算器，探索计算器的基本原理和实现方法。

一、实验目的本实验的主要目的是通过设计和实现一个基本的计算器，加深对Java编程语言的理解和应用。

通过这个实验，我们可以学习到如何设计一个简单的界面，实现基本的计算功能，并对用户输入进行处理和错误处理。

二、实验步骤1. 界面设计首先，我们需要设计一个简单的计算器界面。

可以使用Swing或JavaFX等工具包来实现界面设计。

界面应该包括数字按钮、运算符按钮以及一个显示屏幕等组件。

2. 事件处理接下来，我们需要为每个按钮添加事件处理程序。

当用户点击按钮时，程序应该能够根据按钮的类型执行相应的操作。

例如，当用户点击数字按钮时，程序应该能够将数字显示在屏幕上；当用户点击运算符按钮时，程序应该能够执行相应的运算。

3. 运算逻辑在实现运算逻辑时，我们需要考虑用户的输入和错误处理。

例如，当用户输入非法字符或进行非法操作时，程序应该能够给出相应的提示或错误信息。

同时，我们还需要考虑运算的优先级和顺序，确保计算结果的准确性。

4. 测试和调试完成代码编写后，我们需要进行测试和调试。

通过输入一系列数字和运算符，检查计算器是否能够正确计算并显示结果。

如果发现错误或异常，需要对代码进行调试，找出并解决问题。

三、实验结果经过测试和调试，我们成功实现了一个简单的计算器。

用户可以通过界面上的按钮输入数字和运算符，并在屏幕上显示计算结果。

计算器能够处理用户的输入并进行相应的运算，同时还能够对错误输入进行处理和提示。

四、实验总结通过本实验，我们深入了解了Java编程语言的应用和实践。

通过设计和实现一个简单的计算器，我们掌握了界面设计、事件处理和运算逻辑的基本原理和方法。

同时，我们也学会了如何进行测试和调试，提高了代码的可靠性和稳定性。

JAVA计算器内含源代码精品文档14页

XX学院计算机科学与技术系实验报告课程名称程序设计基础实验(2)实验项目应用系统的面向对象设计与分析实验类型综合性实验完成人所在班级指导教师完成日期2009年11月20日实验报告正文一．实验报告简表实验课题名称计算器综合性实验项目应用系统的面向对象设计与分析服务课程程序设计基础实验(2)实验小组组长指导教师参与实验人员及其在实验课题中承担的主要任务(包括组长)学号小组成员姓名班级在实验课题中的主要作用二、实验内容1、完成计算器的编写。

2、完成实验报告的写作.三、实验要求1、理解并掌握图形界面的设计。

2、理解整体算法的思路，即actionPerformed()的算法.3、进一步学习JAVA的编程思想。

四、实验目的1、理解并掌握图形界面的设计。

2、理解整体算法的思路，即actionPerformed()的算法。

3、通过设计成的计算器的按钮输入所需要计算的数字，根据自己所需进行加减乘除运算，得出结果。

4、进一步学习JAVA的编程思想。

五、实验条件编译器：NetBeansJava环境：JDK 6.0操作系统：Windows XP六、思路分析1.在开始写计算器之前，用笔在纸上画出计算器的草图，显示屏的位置，每个按钮的位置及大小比列。

2.使用setLayout(new GridLayout(6, 3, 10, 10));创建容器框框，使用JPanel JPanel pane = new JPanel();pane.setLayout(new BorderLayout());pane.add(result, BorderLayout.NORTH);pane.add(number_key, BorderLayout.SOUTH);通过之前的草图将按钮位置排好，这样计算器的外部形状也Ok。

3.图形边框解决了之后开始通过getSource（）==“”去的事件源对象，进行实现按钮的输入；4.这是计算器最关键的一步——实现计算器的运算，首先定义四则运算的符号i 。

java 计算器课程设计报告包含代码

课题名称：简单计算器的应用学生指导教师课题名称简单计算器的应用设计时间设计地点设计目的一、课题介绍1、课题要求（1）使用图形用户界面：一个文本框；0-9数字按钮；加、减、乘、除运算符；“等于”符号；复位按钮；（2）完成整数、实数的四则运算（加、减、乘、除）；（3）通过按钮点击实现数据的复位（清零）；（4）实数运算中小数位的精度一致。

2、课题设计思想对于此计算器程序，首先要设计其GUI界面，总体界面有一个文本框，18个按钮，总体界面用BorderLayout布局。

文本框放置在最NORTH，然后0到9以及+，-，*，/的按钮放置到一个面板Panel中，添加到整体布局的CENTER，界面设计完成。

布局设计好后再添加按钮事件。

对于此程序要考虑到点击加、减、乘、除按钮时是否有点击数字按钮，如果是第一次点击数字按钮或者是点击数字按钮前点击了加、减、乘、除按钮则直接把数字按钮的数值设置到文本框中，否则则应把文本框中的内容加上你所点击按钮的数值设置到文本框中。

这是计算器中的一种：简单计算器，本项目用到了Java中的GUI界面和swing组件以及awt布局，所以简单易用，它能完成如下的几个小功能：点击按钮中的数字键和运算符键就能进行简单的加、乘、乘、除求模四则运算；还能通过用户自己在文本框中输入数字，进行简单运算；如果输入有误时可以按Clear撤销后重新输入新数据。

二、详细设计过程1、界面设计界面设计要求用GUI，界面设计中有用到swing组件的TextField和Button，用awt中的BorderLayout和GridLayout布局管理方式，窗体名称jisuan继承JFrameActionListener接口，并实现public void actionPerformed(ActionEvent e){}方法。

定义菜单、菜单条、菜单项、按钮、文本框、容器，设置为private类型。

定义变量double memoryd;//使用内存中存储的数字；DecimalFormat df;//保留小数位数。

java实验报告-计算器附源代码

面向对象程序设计实验报告学院计算机科学与技术学院专业计算机科学与技术学号姓名指导教师2016 年 1 月 1 日一、实验目的参照Windows计算器功能，用java语言编写一个图形化计算器程序，实现加、减、乘、除等运算。

二、实验题目Java计算器的编写三、实验内容import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Calculator extends JFrame implements ActionListener {//定义字符型数组，存放按钮字符private final String[] str = { "sqrt","+/-","CE","C","7", "8", "9", "/", "4", "5", "6", "*", "1","2", "3", "-", "0",".", "=", "+" };//定义按钮数组，用于实现上面的按钮字符JButton[] buttons = new JButton[str.length];//定义文本行，初始显示0JTextField display = new JTextField("0");//计算器构造函数public Calculator() {super("计算器");//panel1是集合了数字和运算符的面板JPanel panel1 = new JPanel(new GridLayout(5, 4)); for (int i = 0; i < str.length; i++) {//把按钮数组加进来buttons[i] = new JButton(str[i]);panel1.add(buttons[i]);}this.addWindowListener(new WinClose());//panel2是文本域和归零面板JPanel panel2 = new JPanel(new BorderLayout()); panel2.add("Center", display);getContentPane().setLayout(new BorderLayout());getContentPane().add("North", panel2);getContentPane().add("Center", panel1);// 为每个数字和运算符按钮添加事件监听器for (int i = 0; i < str.length; i++)buttons[i].addActionListener(this);//为文本域添加事件监听器display.addActionListener(this);//设置窗口位置setBounds(500, 200, 400, 400);//设置框架不能改变大小setResizable(false);//设置组件可见setVisible(true);//调整此窗口的大小，以适合其子组件的首选大小和布局 pack();}//value用来记录当前文本域的数值double value=0;public void actionPerformed(ActionEvent e) {String label = e.getActionCommand();if(label.equals("CE")){display.setText("");}else if(label.equals("C")){handleC();}else if(label.equals("sqrt")){value=Double.parseDouble(display.getText());if(value<0){display.setText("负数不存在平方根!");}else{value=Math.sqrt(value);display.setText(String.valueOf(value));}}else if(label.equals("+/-")){value=Double.parseDouble(display.getText())*(-1);display.setText(String.valueOf(value));}else if ("0123456789.".indexOf(label) >= 0)/*("0123456789.".indexOf(label) >= 0)意思是当前输入的数字是“0123456789”中的一个时，响应输入数字事件，和下面同效果* (label.equals("0")|| label.equals("1")|| label.equals("2")|| label.equals("3")|| label.equals("4")|| label.equals("5")|| label.equals("6")||label.equals("7")||label.equals("8")||label.equals("9")||label.equals("."))*/handleNumber(label);elsehandleOperator(label);}//设置布尔型变量，用于标记是否是第一次按下小数点，初始为是boolean isFirstDigit = true;//响应数字按钮public void handleNumber(String key) {if (isFirstDigit)display.setText(key);else if ((key.equals(".")) && (display.getText().indexOf(".") < 0))display.setText(display.getText() + ".");else if (!key.equals("."))display.setText(display.getText() + key);isFirstDigit = false;}//归零按钮C响应public void handleC() {display.setText("0");isFirstDigit = true;operator = "=";}Double number = 0.0;String operator = "=";//响应运算符按钮public void handleOperator(String key) {if (operator.equals("+")){number += Double.valueOf(display.getText()); display.setText(String.valueOf(number));}else if (operator.equals("-")){number -= Double.valueOf(display.getText()); display.setText(String.valueOf(number));}else if (operator.equals("*")){number *= Double.valueOf(display.getText());display.setText(String.valueOf(number));}else if (operator.equals("/")){if(Double.parseDouble(display.getText())==0){display.setText("error:除数不能为0");}else{number /= Double.valueOf(display.getText());display.setText(String.valueOf(number));}}else if (operator.equals("=")){number = Double.valueOf(display.getText()); display.setText(String.valueOf(number));}operator = key;isFirstDigit = true;}public static void main(String[] args) {//程序入口，新建计算器new Calculator();}}//实现窗口事件监听器接口class WinClose implements WindowListener{public void windowClosing(WindowEvent ev){System.exit(0);}public void windowsOpend(WindowEvent ev){}public void windowActivated(WindowEvent ev){}public void windowsDeactivated(WindowEvent ev){}public void windowClosed(WindowEvent ev){}public void windowIconified(WindowEvent ev){}public void windowDeiconified(WindowEvent ev){}@Overridepublic void windowDeactivated(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowOpened(WindowEvent e) {// TODO Auto-generated method stub}}四、实验结果及分析（一、）程序功能测试：1、加法、减法、乘法、除法测试：20+0.5=20.5100-10.5=89.520*20=4000/2=02/0报错1/2=0.52、Sqrt（开方）测试：√25=5 负数开方报错3、+/-测试：-2+1.5=-0.54、CE（清除当前输入项）和C（清除整个计算式）测试：计算10+20=30时输入10+22然后按下CE清除22，重新输入20。

课程设计报告(java版的计算器源代码)

程序功能简介：从最基本的加、减、乘、除，到基本数学函数处理，再到数的进制转换处理。

代码如下/*文件名：Calculator.java*说明：简易科学计算器*/import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Calculator extends Frame implements ActionListener, WindowListener{private Container container;private GridBagLayout layout;private GridBagConstraints constraints;private JTextField displayField; //计算结果显示区private String lastCommand; //保存+,-,*,/,=命令0private double result; //保存计算结果private boolean start; //判断是否为数字的开始private JMenuBar menubar;private JMenuItem m_exit,m2_ejz,m2_bjz;private Dialog dialog;private Label label_dialog;private JButton button_sqrt,button_plusminus,button_CE,button_cancel,button_1,button_2,button_3,button_4,button_5,button_6,button_7,button_8,button_9,button_0,button_plus,button_minus,button_multiply,button_divide,button_point,button_equal,button_log,button_tan,button_cos,button_sin,button_exp;public Calculator() //构造方法设置布局、为按钮注册事件监听器{super("Calculator");this.setLocation(240,200);this.setSize(350,300);this.setResizable(true);this.setLayout(new GridLayout(7,1));this.addmyMenu(); //调用成员方法添加菜单displayField=new JTextField(30);this.add(displayField);displayField.setEditable(true);start=true;result=0;lastCommand = "=";JPanel panel0=new JPanel();panel0.setLayout(new GridLayout(1,4,4,4));JPanel panel1=new JPanel();panel1.setLayout(new GridLayout(1,5,4,4));this.add(panel1);button_sqrt=new JButton("sqrt");button_plusminus=new JButton("+/-");button_exp=new JButton("exp");button_CE=new JButton("退格");button_cancel=new JButton("C");JPanel panel2=new JPanel();panel2.setLayout(new GridLayout(1,5,4,4));this.add(panel2);button_7=new JButton("7");button_8=new JButton("8");button_9=new JButton("9");button_log=new JButton("log");button_divide=new JButton("/");JPanel panel3=new JPanel();panel3.setLayout(new GridLayout(1,5,4,4));this.add(panel3);button_4=new JButton("4");button_5=new JButton("5");button_6=new JButton("6");button_tan=new JButton("tan");button_multiply=new JButton("*");JPanel panel4=new JPanel();panel4.setLayout(new GridLayout(1,5,4,4));this.add(panel4);button_1=new JButton("1");button_2=new JButton("2");button_3=new JButton("3");button_cos=new JButton("cos");button_minus=new JButton("-");JPanel panel5=new JPanel();panel5.setLayout(new GridLayout(1,5,4,4));this.add(panel5);button_0=new JButton("0");button_point=new JButton(".");button_equal=new JButton("=");button_sin=new JButton("sin");button_plus=new JButton("+");panel1.add(button_sqrt);panel1.add(button_plusminus);panel1.add(button_exp);panel1.add(button_CE);panel1.add(button_cancel);panel2.add(button_7);panel2.add(button_8);panel2.add(button_9);panel2.add(button_log);panel2.add(button_divide);panel3.add(button_4);panel3.add(button_5);panel3.add(button_6);panel3.add(button_tan);panel3.add(button_multiply);panel4.add(button_1);panel4.add(button_2);panel4.add(button_3);panel4.add(button_cos);panel4.add(button_minus);panel5.add(button_0);panel5.add(button_point);panel5.add(button_equal);panel5.add(button_sin);panel5.add(button_plus);button_sqrt.addActionListener(this);button_plusminus.addActionListener(this);button_exp.addActionListener(this);button_CE.addActionListener(this);button_cancel.addActionListener(this);button_7.addActionListener(this);button_8.addActionListener(this);button_9.addActionListener(this);button_log.addActionListener(this);button_divide.addActionListener(this);button_4.addActionListener(this);button_5.addActionListener(this);button_6.addActionListener(this);button_tan.addActionListener(this);button_multiply.addActionListener(this);button_1.addActionListener(this);button_2.addActionListener(this);button_3.addActionListener(this);button_cos.addActionListener(this);button_minus.addActionListener(this);button_0.addActionListener(this);button_point.addActionListener(this);button_equal.addActionListener(this);button_sin.addActionListener(this);button_plus.addActionListener(this);this.addWindowListener(new WinClose()); //注册窗口监听器this.setVisible(true);}private void addmyMenu() //菜单的添加{JMenuBar menubar=new JMenuBar();this.add(menubar);JMenu m1=new JMenu("选项");JMenu m2=new JMenu("进制转换");JMenuItem m1_exit=new JMenuItem("退出");m1_exit.addActionListener(this);JMenuItem m2_ejz=new JMenuItem("二进制");m2_ejz.addActionListener(this);JMenuItem m2_bjz=new JMenuItem("八进制");m2_bjz.addActionListener(this);JMenu m3 = new JMenu(" 帮助");JMenuItem m3_Help = new JMenuItem("用法");m3_Help.addActionListener(this);dialog = new Dialog(this,"提示",true); //模式窗口dialog.setSize(240,80);label_dialog = new Label("",Label.CENTER); //标签的字符串为空，居中对齐dialog.add(label_dialog);dialog.addWindowListener(this); //为对话框注册窗口事件监听器m1.add(m1_exit);menubar.add(m1);m2.add(m2_ejz);m2.add(m2_bjz);menubar.add(m2);m3.add(m3_Help);menubar.add(m3); }public void actionPerformed(ActionEvent e) //按钮的单击事件处理方法{if(e.getSource().equals(button_1)||e.getSource().equals(button_2)||e.getSource().equals(button_3)||e.getSource().equals(button_4)||e.getSource().equals(button_5)|| e.getSource().equals(button_6)||e.getSource().equals(button_7)|| e.getSource().equals(button_8)||e.getSource().equals(button_9) ||e.getSource().equals(button_0)||e.getSource().equals(button_point)||e.getSource().equals(button_plusminus)||e.getSource().equals(button_cancel)||e.getSource().equals(button_CE)){ //非运算符的处理方法String input=e.getActionCommand();if (start){displayField.setText("");start=false;if(input.equals("+/-"))displayField.setText(displayField.getText()+"-");}if(!input.equals("+/-")){String str=displayField.getText();if(input.equals("退格")) //退格键的实现方法{if(str.length()>0)displayField.setText(str.substring(0,str.length()-1));}else if(input.equals("C")) //清零键的实现方法{displayField.setText("0");start=true;}elsedisplayField.setText(displayField.getText()+input);}}else if (e.getActionCommand()=="二进制") //二进制的转换{int n=Integer.parseInt(displayField.getText());displayField.setText(Integer.toBinaryString(n));}else if (e.getActionCommand()=="八进制") //八进制的转换{int n=Integer.parseInt(displayField.getText());displayField.setText(Integer.toOctalString(n));}else if (e.getActionCommand()=="退出") //选项中退出的处理方法{System.exit(0);}else if (e.getActionCommand()=="用法") //按下'帮助'菜单栏中用法的处理方法{label_dialog.setText("sqrt,exp等键是先输运算符再输数字\n");dialog.setLocation(400,250);dialog.setVisible(true);}else //各运算符的识别{String command=e.getActionCommand();if(start){lastCommand=command;}else{calculate(Double.parseDouble(displayField.getText()));lastCommand=command;start=true;}}}public void calculate(double x) //各运算符的具体运算方法double d=0;if (lastCommand.equals("+"))result+= x;else if (lastCommand.equals("-"))result-=x;else if (lastCommand.equals("*"))result*=x;else if (lastCommand.equals("/"))result/=x;else if (lastCommand.equals("="))result=x;else if (lastCommand.equals("sqrt")){d=Math.sqrt(x);result=d;}else if (lastCommand.equals("exp")){d=Math.exp(x);result=d;}else if (lastCommand.equals("log")){d=Math.log(x);result=d;}else if (lastCommand.equals("tan")){d=Math.tan(x);result=d;}else if (lastCommand.equals("cos")){d=Math.cos(x);result=d;}else if (lastCommand.equals("sin")){d=Math.sin(x);result=d;}displayField.setText(""+ result);}public void windowClosing(WindowEvent e){if(e.getSource()==dialog)dialog.setVisible(false); //隐藏对话框 elseSystem.exit(0);public void windowOpened(WindowEvent e) { }public void windowActivated(WindowEvent e) { }public void windowDeactivated(WindowEvent e) { }public void windowClosed(WindowEvent e) { }public void windowIconified(WindowEvent e) { }public void windowDeiconified(WindowEvent e) { }public static void main(String args[]){Calculator calculator=new Calculator();}}class WinClose implements WindowListener{public void windowClosing(WindowEvent e) //单击窗口关闭按钮时触发并执行实现窗口监听器接口中的方法{System.exit(0); //结束程序运行}public void windowOpened(WindowEvent e){}public void windowActivated(WindowEvent e){}public void windowDeactivated(WindowEvent e){}public void windowClosed(WindowEvent e){}public void windowIconified(WindowEvent e){}public void windowDeiconified(WindowEvent e){}}运行结果截图：程序功能实现：1.运用两个面板的叠加做出界面。

java课设计算器报告

java课设计算器报告
今天，我们取得了一个令人惊叹的成果：利用Java语言实现了简单的计算器，它可以进行多种数学运算。

本报告展示了其原理与实施过程，并讨论了开发过程中涉及到的关键思想与核心技术。

本课设计报告是针对使用Java编写的计算器的一个评估报告，以下是详细内容：
1.项目背景:由于现在计算机发展得很快，计算机语言也是随之发展起来，更多的语言可以实现各种功能，而Java语言作为编程语言被广泛应用，本次课设希望能够利用Java编写一个小型计算器。

2.功能实现:通过Java编写简单计算器，实现输入两个参数，然后进行加减乘除的计算。

3.开发过程:
（1）首先要创建一个Java程序，然后定义两个变量，用于存放输入的参数。

（2）然后为程序添加输入的函数，以获取用户输入的参数。

（3）利用if语句判断用户输入的运算符号，根据不同的运算符号，调用相应的函数进行计算。

（4）将计算结果输出，以及耗时等信息。

4.评估结果:本次使用Java实现了一个小型计算器，实现了加减乘除功能。

整个程序的开发流程非常顺利，而且具有良好的可实施性和可维护性，程序运行流畅，计算结果准确，性能极佳。

Java程序设计实验报告_2

Java程序设计实验报告姓名：学号：班级：课题名称（附程序名）：JAVA计算器（Calculator.java）一、实验目的通过JAVA图形接口的应用，编写出一图形界面的科学计算器；熟悉JAVA程序开发的一般步骤，掌握事件驱动，并能掌握一定的Java 编程能力，在实践中能感受Java的奥秘！同时检验自己的学习成果。

二、实验任务具有加减乘除的计算器，可以延伸到开方等其他的一些计算。

三、开发工具与平台Microsoft Visual Studio 2005四、设计思路：1)界面设计2)逻辑设计首先明确该实验设计的要求实现的基本功能，其次设计布局，将空间划分为由行和列组成的网格单元，每个单元放一个组件，网格单元大小可以不同，尽量将相同属性的按钮放在一个区域，方便操作。

3)软件调试与测试经过调试之后，能实现基本的四则运算，并能实现开方和消除错误的数。

4)软件设计优化该软件的界面应该更加流畅，同时我相信随着自己只是的日益丰富，开发软件的速度更快，效率更高，功能更加全面！5)实验总结不足：没有实现Mc,MR,MS,M+以及菜单栏几个功能，有待进一步完善。

这样才能够完成自己的第一个应用软件设计！优点：通过本次实验设计，大体了解了Java图形接口的应用，并在过程中增强了对程序的调试能力。

对JAVA有了更深一步的理解，学会如何解决问题，如何坚持对程序的调试，同时也增强了自己学习Java的信心。

五、附录源程序如下：import java.awt.BorderLayout;import java.awt.Container;import java.awt.GridBagConstraints;import java.awt.GridBagLayout;import java.awt.GridLayout;import java.awt.Insets;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.MouseEvent;import java.awt.event.MouseListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JMenu;import javax.swing.JMenuBar;import javax.swing.JPanel;import javax.swing.JTextField;public class Calculator extends JFrame implements ActionListener { boolean init = true;boolean isMath = false;boolean clear = true;boolean clickable = true;double qian;String fuhao;int all = 0;JTextField text = new JTextField(25);JButton bM = new JButton();JButton bMC = new JButton("MC");JButton bMR = new JButton("MR");JButton bMS = new JButton("MS");JButton bMADD = new JButton("M+");JButton b0 = new JButton("0");JButton b1 = new JButton("1");JButton b2 = new JButton("2");JButton b3 = new JButton("3");JButton b4 = new JButton("4");JButton b5 = new JButton("5");JButton b6 = new JButton("6");JButton b7 = new JButton("7");JButton b8 = new JButton("8");JButton b9 = new JButton("9");JButton bNOP = new JButton("+/-");JButton bDot = new JButton(".");JButton bDiv = new JButton("/");JButton bMul = new JButton("*");JButton bSub = new JButton("-");JButton bAdd = new JButton("+");JButton bSprt = new JButton("sprt");JButton bMod = new JButton("%");JButton bDao = new JButton("1/x");JButton bEqual = new JButton("=");JButton bBackspace = new JButton("Backspace"); JButton bCE = new JButton("CE");JButton bC = new JButton("C");public Calculator() {this.setTitle("计算器");JMenuBar mainMenu = new JMenuBar();setJMenuBar(mainMenu);JMenu editMenu = new JMenu("编辑");JMenu viewMenu = new JMenu("查看");JMenu helpMenu = new JMenu("帮助");mainMenu.add(editMenu);mainMenu.add(viewMenu);mainMenu.add(helpMenu);JPanel jpDisplay = new JPanel();JPanel jpInput = new JPanel();JPanel jpLeft = new JPanel();JPanel jpRight = new JPanel();text.setText("0.");text.setHorizontalAlignment(JTextField.RIGHT); jpDisplay.add(text);bM.addActionListener(this);bMC.addActionListener(this);bMS.addActionListener(this);bMR.addActionListener(this);bMADD.addActionListener(this);jpLeft.setLayout(new GridLayout(5, 1)); jpLeft.add(bM);jpLeft.add(bMC);jpLeft.add(bMR);jpLeft.add(bMS);jpLeft.add(bMADD);JPanel jpInnerN = new JPanel();JPanel jpInnerS = new JPanel();bBackspace.addActionListener(this);bCE.addActionListener(this);bC.addActionListener(this);jpInnerN.setLayout(new GridLayout(1, 3)); jpInnerN.add(bBackspace);jpInnerN.add(bCE);jpInnerN.add(bC);b0.addActionListener(this);b1.addActionListener(this);b2.addActionListener(this);b3.addActionListener(this);b4.addActionListener(this);b5.addActionListener(this);b6.addActionListener(this);b7.addActionListener(this);b8.addActionListener(this);b9.addActionListener(this);bNOP.addActionListener(this);bDot.addActionListener(this);bDiv.addActionListener(this);bMul.addActionListener(this);bSub.addActionListener(this);bAdd.addActionListener(this);bSprt.addActionListener(this);bMod.addActionListener(this);bDao.addActionListener(this);bEqual.addActionListener(this);jpInnerS.setLayout(new GridLayout(4, 5));jpInnerS.add(b7);jpInnerS.add(b8);jpInnerS.add(b9);jpInnerS.add(bDiv);jpInnerS.add(bSprt);jpInnerS.add(b4);jpInnerS.add(b5);jpInnerS.add(b6);jpInnerS.add(bMul);jpInnerS.add(bMod);jpInnerS.add(b1);jpInnerS.add(b2);jpInnerS.add(b3);jpInnerS.add(bSub);jpInnerS.add(bDao);jpInnerS.add(b0);jpInnerS.add(bNOP);jpInnerS.add(bDot);jpInnerS.add(bAdd);jpInnerS.add(bEqual);jpRight.setLayout(new BorderLayout());jpRight.add(jpInnerN, BorderLayout.NORTH);jpRight.add(jpInnerS, BorderLayout.CENTER);jpInput.setLayout(new BorderLayout());jpInput.add(jpLeft, BorderLayout.WEST);jpInput.add(jpRight, BorderLayout.CENTER);Container pane = this.getContentPane();pane.setSize(333, 208);this.setLocation(300, 200);this.setLayout(new BorderLayout());pane.add(jpDisplay, BorderLayout.CENTER);pane.add(jpInput, BorderLayout.SOUTH);this.setDefaultCloseOperation(EXIT_ON_CLOSE);this.pack();this.setVisible(true);}public void actionPerformed(ActionEvent e) {if (init)this.text.setText("0.");init = false;Object source = e.getSource();if (source == bBackspace) {String s = text.getText();text.setText("");for (int i = 0; i < s.length() - 1; i++) { char a = s.charAt(i);text.setText(text.getText() + a);}System.out.println("backspace");}if (source == bCE) {text.setText("0.");clear = true;init = true;System.out.println("CE");}if (source == bC) {text.setText("0.");clear = true;init = true;System.out.println("C");}if (source == bM) {System.out.println("M");}if (source == bMC) {System.out.println("MC,功能末实现");}if (source == bMR) {System.out.println("MR,功能末实现");}if (source == bMS) {System.out.println("MS,功能末实现");}if (source == bMADD) {System.out.println("M+,功能末实现");}if (source == b0) {System.out.println("0");if (clear == false)// 判断是否点击了符号位text.setText("");text.setText(text.getText() + "0");}if (source == b1) {if (clear == false)text.setText("");text.setText(text.getText() + "1");clear = true;// 第二次不在清空（前二句）}if (source == b2) {System.out.println("2");if (clear == false)text.setText("");text.setText(text.getText() + "2");clear = true;}if (source == b3) {System.out.println("3");if (clear == false)text.setText("");text.setText(text.getText() + "3");clear = true;}if (source == b4) {System.out.println("4");if (clear == false)text.setText("");text.setText(text.getText() + "4");clear = true;}if (source == b5) {System.out.println("5");if (clear == false)text.setText("");text.setText(text.getText() + "5");clear = true;}if (source == b6) {System.out.println("6");if (clear == false)text.setText("");text.setText(text.getText() + "6");clear = true;}if (source == b7) {System.out.println("7");if (clear == false)text.setText("");text.setText(text.getText() + "7");clear = true;}if (source == b8) {System.out.println("8");if (clear == false)text.setText("");text.setText(text.getText() + "8");clear = true;}if (source == b9) {System.out.println("9");if (clear == false)text.setText("");text.setText(text.getText() + "9");clear = true;}try{if (source == bNOP) {System.out.println("+/-");boolean isNumber = true;String s = text.getText();for (int i = 0; i < s.length(); i++)if (!(s.charAt(i) >= '0' && s.charAt(i) <= '9'|| s.charAt(i) == '.' || s.charAt(i) == '-')) {isNumber = false;break;}if (isNumber == true) {// 如果当前字符串首字母有'-'号,代表现在是个负数,再按下时,则将首符号去掉if (s.charAt(0) == '-') {text.setText("");for (int i = 1; i < s.length(); i++) {char a = s.charAt(i);text.setText(text.getText() + a);}}// 如果当前字符串第一个字符不是符号，则添加一个符号在首字母处elsetext.setText('-' + s);}}if (source == bDot) {System.out.println(".");clickable = true;for (int i = 0; i < text.getText().length(); i++)if ('.' == text.getText().charAt(i)) {clickable = false;break;} // 第一层判断是否里面含有小数点;if (clickable == true)// 第二层判断text.setText(text.getText() + ".");}if (source == bDiv) {System.out.println("/");qian = Double.parseDouble(text.getText());fuhao = "/";clear = false;}if (source == bMul) {System.out.println("*");qian = Double.parseDouble(text.getText());fuhao = "*";clear = false;}if (source == bSub) {System.out.println("-");qian = Double.parseDouble(text.getText());fuhao = "-";clear = false;}if (source == bAdd) {System.out.println("+");qian = Double.parseDouble(text.getText());fuhao = "+";clear = false;}if (source == bSprt) {System.out.println("sprt");String s = text.getText();if (s.charAt(0) == '-') {text.setText("负数不能开根号");} elsetext.setText(Double.toString(ng.Math.sqrt(Double.parseDouble(text.getText()))));clear = false;}if (source == bMod) {System.out.println("%,功能末实现");}if (source == bDao) {System.out.println("1/x");if (text.getText().charAt(0) == '0'&& text.getText().length() == 1) {text.setText("除数不能为零");} else {boolean isDec = true;int i, j, k;String s= Double.toString(1 / Double.parseDouble(text.getText()));for (i = 0; i < s.length(); i++)if (s.charAt(i) == '.')break;for (j = i + 1; j < s.length(); j++)if (s.charAt(j) != '0') {isDec = false;break;}if (isDec == true) {String stemp = "";for (k = 0; k < i; k++)stemp += s.charAt(k);text.setText(stemp);} elsetext.setText(s);}clear = false;}if (source == bEqual) {System.out.println("=");Double ss=Double.parseDouble(text.getText());text.setText("");if (fuhao == "+")text.setText(qian + ss + "");if (fuhao == "-")text.setText(qian - ss + "");if (fuhao == "*")text.setText(qian * ss + "");if (fuhao == "/")text.setText(qian / ss + "");clear = false;// 要清空前一次的数据;}}catch (Exception ee) {System.out.println("请正确输入");text.setText("运算出错,给您带来不便,sorry");clear = false;}}public static void main(String[] args) {new Calculator();}}11。

java 计算器实验报告

java 计算器实验报告Java计算器实验报告引言：计算器是我们日常生活中常用的工具，使用计算器可以快速进行数学运算。

在计算器中，我们可以通过输入数字和运算符来执行各种算术操作。

为了更好地理解计算器的工作原理，我们进行了Java计算器的实验。

一、实验目的本次实验的目的是设计和实现一个简单的Java计算器。

通过这个实验，我们可以加深对Java编程语言的理解，并且掌握Java图形用户界面（GUI）的基本知识。

二、实验环境本次实验使用的是Java开发工具包（JDK）和Eclipse集成开发环境（IDE）。

在实验之前，我们需要确保已经正确安装了JDK和Eclipse。

三、实验步骤1. 创建一个新的Java项目，并命名为"Calculator"。

2. 在项目中创建一个新的Java类，命名为"CalculatorGUI"。

3. 在"CalculatorGUI"类中，创建一个窗口，并设置窗口的标题和大小。

4. 在窗口中添加一个文本框，用于显示计算结果。

5. 在窗口中添加一些按钮，用于输入数字和运算符。

6. 为每个按钮添加事件监听器，以便在用户点击按钮时执行相应的操作。

7. 实现计算器的基本功能，包括加法、减法、乘法和除法。

8. 运行程序，测试计算器的功能。

四、实验结果经过实验，我们成功地实现了一个简单的Java计算器。

用户可以通过按钮输入数字和运算符，并且计算器可以正确地执行相应的运算。

计算结果会显示在文本框中。

五、实验总结通过这个实验，我们学习了如何使用Java编程语言创建图形用户界面，并且掌握了Java计算器的基本实现方法。

在实验过程中，我们遇到了一些问题，比如如何处理用户输入错误的情况，如何处理除数为零的情况等。

通过不断调试和改进，我们最终解决了这些问题，并实现了一个功能完善的计算器。

在今后的学习和工作中，我们可以进一步扩展这个计算器的功能，比如添加科学计算功能、实现复杂运算等。

Java简单计算器(程序设计报告)

JA V A课程设计报告哈尔滨哈商业大学JAVA课程设计课程名称：Java程序设计课题名称：简单计算器*名：***学号：************班级：08级软件工程教育2011年10月20日一、实验目的：使用Eclipse软件制作简单计算器，实现加减乘除等基本功能。

二、实验源码：import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Calculator {public static void main(String[] args) {EventQueue.invokeLater(new Runnable(){public void run(){CalculatorFrame frame = new CalculatorFrame();frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setVisible(true);}});}}class CalculatorFrame extends JFrame{public CalculatorFrame(){setTitle("Calculator");CalculatorPanal panel = new CalculatorPanal();add(panel);pack();}}class CalculatorPanal extends JPanel{public CalculatorPanal(){setLayout(new BorderLayout());result =0;lastCommand = "=";start = true;display = new JButton("0");display.setEnabled(false);add(display,BorderLayout.NORTH);ActionListener insert= new InsertAction();ActionListener command=new CommantAction();panel = new JPanel();panel.setLayout(new GridLayout(4,4));addButton("7",insert);addButton("8",insert);addButton("9",insert);addButton("/",command);addButton("4",insert);addButton("5",insert);addButton("6",insert);addButton("*",command);addButton("1",insert);addButton("2",insert);addButton("3",insert);addButton("-",command);addButton("0",insert);addButton(".",insert);addButton("=",command);addButton("+",command);add(panel,BorderLayout.CENTER);}private void addButton(String label,ActionListener listener) {JButton button = new JButton(label);button.addActionListener(listener);panel.add(button);}private class InsertAction implements ActionListener{public void actionPerformed(ActionEvent event){String input = event.getActionCommand();if(start){display.setText("");start= false;}display.setText(display.getText()+input);}}private class CommantAction implements ActionListener{public void actionPerformed(ActionEvent event){String command = event.getActionCommand();if(start){if(command.equals("-")){display.setText(command);start= false;}else lastCommand = command;}else{calculate(Double.parseDouble(display.getText()));lastCommand =command;start =true;}}}public void calculate(double x){if(lastCommand.equals("+")) result +=x;else if(lastCommand.equals("-")) result -=x;else if(lastCommand.equals("*")) result *=x;else if(lastCommand.equals("/")) result /=x;else if(lastCommand.equals("=")) result =x;display.setText(""+result);}private JButton display;private JPanel panel;private double result;private String lastCommand;private boolean start;}三、实验结果：。

(完整word版)Java计算器实验报告

一、目标：通过Java程序开发实训使学生掌握《面向对象程序设计(Java)》课堂讲授的内容，灵活运用到Java程序的开发与设计中。

二、要求：按时参加Java程序开发实训训练，不得迟到和早退；独立完成程序设计；按要求撰写实践报告。

三、详细内容：使用《面向对象程序设计(Java)》课程讲授内容，编写一个简单的计算器，要求实现如下功能：1.进行图形界面设计通过图形界面设计，掌握JFrame类、JPanel类、5种布局管理器、文本框、标签及按钮的使用方法。

2.实现计算器的基本功能包括加减乘除四则运算、倒数、平方根及清除结果等功能。

3.实现计算器的存储计算功能包括存储中间结果（MS）、使用中间结果（MR）、累加中间结果（M+）及清除中间结果（MC）的功能。

4.计算器的扩展功能包括乘方、对数、正弦、余弦、正切、余切、反正弦、反余弦、反正切、反余切及2进制、8进制、16进制、10进制之间的相互转换等功能。

四、源代码import java.awt.BorderLayout;import java.awt.Color;import java.awt.FlowLayout;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyEvent;import java.text.DecimalFormat;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JMenu;import javax.swing.JMenuBar;import javax.swing.JMenuItem;import javax.swing.JPanel;import javax.swing.JScrollPane;import javax.swing.JTextArea;import javax.swing.JTextField;public class jsq implements ActionListener { //导入动作监听接口//设计面板中的单位JFrame frame;//窗口JTextField textAnswer;//文本JPanel panel, panel1, panel2, panel3;//面版JMenuBar mainMenu;//菜单JTextField textMemory;JLabel labelMemSpace; //labelMemSpace单纯做摆设，控制面板的形状JButton buttonBk, buttonCe, buttonC;JButton button[];//按钮数组JButton buttonMC, buttonMR, buttonMS, buttonMAdd;//清除,使用,储存,添加JButton buttonDot, buttonAddAndSub, buttonAdd, buttonSub, buttonMul,buttonDiv, buttonMod;JButton buttonSqrt, buttonDao, buttonEqual;JMenu editMenu, viewMenu, helpMenu;JMenuItem copyItem, pasteItem, tItem, sItem, numberGroup,topHelp,aboutCal;DecimalFormat df; //设置数据输出精度boolean clickable; //控制当前能否按键double memoryd; //使用内存中存储的数字int memoryi;double vard, answerd; //用来保存double型数据的中间值(vard)和最后结果(answerd)short key = -1, prekey = -1; //key用来保存当前进行何种运算,prekey用来保存前次进行何种运算String copy; //做复制用JTextArea help; //帮助JScrollPane scrollHelp;//构造函数public jsq() {clickable = true;answerd = 0;frame = new JFrame("计算器");df = new DecimalFormat("0.##############"); //设置数据输出精度(对于double型值)textAnswer = new JTextField(15);textAnswer.setText("");textAnswer.setEditable(false);textAnswer.setBackground(new Color(255, 255, 255));panel = new JPanel();frame.getContentPane().add(panel);panel1 = new JPanel();panel2 = new JPanel();panel.setLayout(new BorderLayout());//设计整个面板mainMenu = new JMenuBar();editMenu =new JMenu("编辑(E)");editMenu .setMnemonic(KeyEvent.VK_E);viewMenu =new JMenu("查看(V)");viewMenu .setMnemonic(KeyEvent.VK_V);helpMenu =new JMenu("帮助(H)");helpMenu .setMnemonic(KeyEvent.VK_H);mainMenu .add(editMenu );mainMenu .add(viewMenu );mainMenu .add(helpMenu );panel.add(mainMenu, BorderLayout.NORTH);panel.add(textAnswer, BorderLayout.CENTER);panel.add(panel1, BorderLayout.SOUTH);panel1.setLayout(new BorderLayout());textMemory = new JTextField(3);textMemory.setEditable(false);textMemory.setBackground(new Color(217, 217, 217));labelMemSpace = new JLabel(" ");buttonBk = new JButton("Backspace");buttonBk.setForeground(new Color(255, 0, 0));buttonCe = new JButton("CE");buttonCe.setForeground(new Color(255, 0, 0));buttonC = new JButton("C");buttonC.setForeground(new Color(255, 0, 0));buttonBk.addActionListener(this);buttonCe.addActionListener(this);buttonC.addActionListener(this);panel1.add(panel2, BorderLayout.NORTH);panel2.setLayout(new FlowLayout(FlowLayout.RIGHT));panel2.add(textMemory);panel2.add(labelMemSpace);panel2.add(buttonBk);panel2.add(buttonCe);panel2.add(buttonC);panel3 = new JPanel();panel1.add(panel3, BorderLayout.CENTER);button = new JButton[10];for (int i = 0; i < button.length; i++) {button[i] = new JButton(Integer.toString(i));button[i].setForeground(new Color(0, 0, 255));}//构造按钮buttonMC = new JButton("MC");buttonMC.setForeground(new Color(255, 0, 0));buttonMR = new JButton("MR");buttonMR.setForeground(new Color(255, 0, 0));buttonMS = new JButton("MS");buttonMS.setForeground(new Color(255, 0, 0));buttonMAdd = new JButton("M+");buttonMAdd.setForeground(new Color(255, 0, 0));buttonDot = new JButton(".");buttonDot.setForeground(new Color(0, 0, 255));buttonAddAndSub = new JButton("+/-");buttonAddAndSub.setForeground(new Color(0, 0, 255));buttonAdd = new JButton("+");buttonAdd.setForeground(new Color(255, 0, 0));buttonSub = new JButton("-");buttonSub.setForeground(new Color(255, 0, 0));buttonMul = new JButton("*");buttonMul.setForeground(new Color(255, 0, 0)); buttonDiv = new JButton("/");buttonDiv.setForeground(new Color(255, 0, 0)); buttonMod = new JButton("%");buttonMod.setForeground(new Color(0, 0, 255)); buttonSqrt = new JButton("sqrt");buttonSqrt.setForeground(new Color(0, 0, 255)); buttonDao = new JButton("1/x");buttonDao.setForeground(new Color(0, 0, 255)); buttonEqual = new JButton("=");buttonEqual.setForeground(new Color(255, 0, 0)); //将所有行为与监听绑定panel3.setLayout(new GridLayout(4, 6));panel3.add(buttonMC);buttonMC.addActionListener(this);panel3.add(button[7]);button[7].addActionListener(this);panel3.add(button[8]);button[8].addActionListener(this);panel3.add(button[9]);button[9].addActionListener(this);panel3.add(buttonDiv);buttonDiv.addActionListener(this);panel3.add(buttonSqrt);buttonSqrt.addActionListener(this);panel3.add(buttonMR);buttonMR.addActionListener(this);panel3.add(button[4]);button[4].addActionListener(this);panel3.add(button[5]);button[5].addActionListener(this);panel3.add(button[6]);button[6].addActionListener(this);panel3.add(buttonMul);buttonMul.addActionListener(this);panel3.add(buttonMod);buttonMod.addActionListener(this);panel3.add(buttonMS);buttonMS.addActionListener(this);panel3.add(button[1]);button[1].addActionListener(this);panel3.add(button[2]);button[2].addActionListener(this);panel3.add(button[3]);button[3].addActionListener(this);panel3.add(buttonSub);buttonSub.addActionListener(this);panel3.add(buttonDao);buttonDao.addActionListener(this);panel3.add(buttonMAdd);buttonMAdd.addActionListener(this);panel3.add(button[0]);button[0].addActionListener(this);panel3.add(buttonAddAndSub);buttonAddAndSub.addActionListener(this);panel3.add(buttonDot);buttonDot.addActionListener(this);panel3.add(buttonAdd);buttonAdd.addActionListener(this);panel3.add(buttonEqual);buttonEqual.addActionListener(this);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.pack();frame.show();}//设置各个按钮行为public void actionPerformed(ActionEvent event) {boolean sign = false; //判断是否是double型数参与运算，是为true，不是为falseObject temp = event.getSource();try {//如果按下数据按钮，将按下的按钮代表的数据插入的当前文本框字符串之后for (int i = 0; i <= 9; i++)if (temp == button[i] && clickable == true)textAnswer.setText(textAnswer.getText() + Integer.toString(i));//按下"."按钮时，判断当前文本框内字符串中含不含"."，如果已含，则不允许再插入"."if (temp == buttonDot && clickable == true) {boolean isDot = false;if (textAnswer.getText().length() == 0) isDot = true;for(int i = 0; i < textAnswer.getText().length(); i++)if ('.' == textAnswer.getText().charAt(i)) { isDot = true;break;}if (isDot == false)textAnswer.setText(textAnswer.getText() + ".");}if ((temp == buttonAdd || temp == buttonSub || temp == buttonMul || temp == buttonDiv)&& clickable == true) {//"+"操作if (temp == buttonAdd) {switch (prekey) {case 0:answerd +=Double.parseDouble(textAnswer.getText());break;case 1:answerd -=Double.parseDouble(textAnswer.getText());break;case 2:answerd *=Double.parseDouble(textAnswer.getText());break;case 3:if (Double.parseDouble(textAnswer.getText()) == 0) {//textAnswer="aa";textAnswer.setText("除数不能为零");clickable = false;} elseanswerd /=Double.parseDouble(textAnswer.getText());break;default:answerd =Double.parseDouble(textAnswer.getText());}textAnswer.setText("");prekey = key = 0;}//"-"操作if (temp == buttonSub) {switch (prekey) {case 0:answerd +=Double.parseDouble(textAnswer.getText());break;case 1:answerd -=Double.parseDouble(textAnswer.getText());break;case 2:answerd *=Double.parseDouble(textAnswer.getText());break;case 3:if (Double.parseDouble(textAnswer.getText()) == 0) {textAnswer.setText("除数不能为零");clickable = false;} elseanswerd /=Double.parseDouble(textAnswer.getText());break;default:answerd =Double.parseDouble(textAnswer.getText());}textAnswer.setText("");prekey = key = 1;}//"*"操作if (temp == buttonMul) {switch (prekey) {case 0:answerd +=Double.parseDouble(textAnswer.getText());break;case 1:answerd -=Double.parseDouble(textAnswer.getText());break;case 2:answerd *=Double.parseDouble(textAnswer.getText());break;case 3:if (Double.parseDouble(textAnswer.getText()) == 0) {textAnswer.setText("除数不能为零");clickable = false;} elseanswerd /=Double.parseDouble(textAnswer.getText());break;default:answerd =Double.parseDouble(textAnswer.getText());}//textAnser = "";textAnswer.setText("");prekey = key = 2;}//"/"操作if (temp == buttonDiv) {switch (prekey) {case 0:answerd +=Double.parseDouble(textAnswer.getText());break;case 1:answerd -=Double.parseDouble(textAnswer.getText());break;case 2:answerd *=Double.parseDouble(textAnswer.getText());break;case 3:if (Double.parseDouble(textAnswer.getText()) == 0) {textAnswer.setText("除数不能为零");clickable = false;} elseanswerd /=Double.parseDouble(textAnswer.getText());break;default:answerd =Double.parseDouble(textAnswer.getText());}textAnswer.setText("");prekey = key = 3;}}//"="操作if (temp == buttonEqual && clickable == true) {//如果连续按"=",则进行连续运算if (prekey == 5) {if (key == 0) {answerd += vard;textAnswer.setText(df.format(answerd));}if (key == 1) {answerd -= vard;textAnswer.setText(df.format(answerd));}if (key == 2) {answerd *= vard;textAnswer.setText(df.format(answerd));}if (key == 3) {if (Double.parseDouble(textAnswer.getText()) == 0) {textAnswer.setText("除数不能为零");clickable = false;} else {answerd /= vard;textAnswer.setText(df.format(answerd));}}} else {vard = Double.parseDouble(textAnswer.getText());if (key == 0) {prekey = -1;answerd +=Double.parseDouble(textAnswer.getText());textAnswer.setText(df.format(answerd));}if (key == 1) {prekey = -1;answerd -=Double.parseDouble(textAnswer.getText());textAnswer.setText(df.format(answerd));}if (key == 2) {prekey = -1;answerd *=Double.parseDouble(textAnswer.getText());textAnswer.setText(df.format(answerd));}if (key == 3) {prekey = -1;if (Double.parseDouble(textAnswer.getText()) == 0) {textAnswer.setText("除数不能为零");clickable = false;} else {answerd /=Double.parseDouble(textAnswer.getText());textAnswer.setText(df.format(answerd));}}}prekey = 5;}//"%"操作，对第二个操作数除以100if (temp == buttonMod && clickable == true) {if (answerd == 0) {String s = textAnswer.getText();textAnswer.setText(s);} else {boolean isDot = false;for (int i = 0; i < textAnswer.getText().length(); i++)if ('.' == textAnswer.getText().charAt(i)) { isDot = true;break;}//如果是double数，除100if (isDot == true) {double dtemp =Double.parseDouble(textAnswer.getText());dtemp = dtemp / 100.0;textAnswer.setText(Double.toString(dtemp));} else {//如果是int数但能被100整除，则去掉末尾两个零if (Integer.parseInt(textAnswer.getText()) % 100 == 0) {int itemp =Integer.parseInt(textAnswer.getText());itemp /= 100;textAnswer.setText(Integer.toString(itemp));}//如果是int数，但不能被100整除，则按double数处理else {double dtemp = Double.parseDouble(textAnswer .getText());dtemp = dtemp / 100.0;textAnswer.setText(Double.toString(dtemp));}}}}//开根号运算if (temp == buttonSqrt && clickable == true) { String s = textAnswer.getText();if (s.charAt(0) == '-') {textAnswer.setText("负数不能开根号");clickable = false;} elsetextAnswer.setText(Double.toString(ng.Math .sqrt(Double.parseDouble(textAnswer.getTex t()))));}//倒数运算if (temp == buttonDao && clickable == true) {if (textAnswer.getText().charAt(0) == '0' && textAnswer.getText().length() == 1) {textAnswer.setText("零不能求倒数");clickable = false;} else {boolean isDec = true;int i, j, k;String s = Double.toString(1 / Double.parseDouble(textAnswer.getText()));for (i = 0; i < s.length(); i++)if (s.charAt(i) == '.')break;for (j = i + 1; j < s.length(); j++)if (s.charAt(j) != '0') {isDec = false;break;}if (isDec == true) {String stemp = "";for (k = 0; k < i; k++)stemp += s.charAt(k);textAnswer.setText(stemp);} elsetextAnswer.setText(s);}}//按下"+/-"按钮时处理if (temp == buttonAddAndSub && clickable == true) {boolean isNumber = true;String s = textAnswer.getText();for (int i = 0; i < s.length(); i++)if (!(s.charAt(i) >= '0' && s.charAt(i) <= '9' || s.charAt(i) == '.'|| s.charAt(i) == '-')) {isNumber = false;break;}if (isNumber == true) {//如果当前字符串首字母有'-'号,代表现在是个负数,再按下时,则将首符号去掉if (s.charAt(0) == '-') {textAnswer.setText("");for (int i = 1; i < s.length(); i++) {char a = s.charAt(i);textAnswer.setText(textAnswer.getText() + a);}}//如果当前字符串第一个字符不是符号，则添加一个符号在首字母处elsetextAnswer.setText('-' + s);}}//计算器有关内存操作//'MC'的操作，将内存清0if (temp == buttonMC && clickable == true) {memoryd = memoryi = 0;textMemory.setText("");}//'MS'的操作，将当前文本框内容保存入内存，显示'M'if (temp == buttonMS && clickable == true) {boolean isDot = false;textMemory.setText(" M");for(int i = 0; i < textAnswer.getText().length(); i++)if ('.' == textAnswer.getText().charAt(i)) { isDot = true;break;}//如果是double,则存入memoryd(double存储器)if (isDot == true) {memoryd =Double.parseDouble(textAnswer.getText());memoryi = 0; //保证存储器中存放最新的值}//如果是int,则存入memoryi(int存储器)else {memoryi = Integer.parseInt(textAnswer.getText());memoryd = 0; //保证存储器中存放最新的值}}//'MR'的操作，将存储器中的信息输出if (temp == buttonMR && clickable == true) {if (memoryd != 0)textAnswer.setText(Double.toString(memoryd));if (memoryi != 0)textAnswer.setText(Integer.toString(memoryi));}//'M+'的功能，将当前文本框里的数据和存储器中数据相加后，再存入存储器if (temp == buttonMAdd && clickable == true) {boolean isDot = false;for(int i = 0; i < textAnswer.getText().length(); i++)if ('.' == textAnswer.getText().charAt(i)) { isDot = true;break;}if (memoryi != 0) { //存储中是一个int型数if (isDot == false) //被加数是一个int型数memoryi +=Integer.parseInt(textAnswer.getText());else { //被加数是一个double型数，则将int存储器中数传入double存储器与当前数相加，int存储器清零memoryd = memoryi+Double.parseDouble(textAnswer.getText());memoryi = 0;}} elsememoryd +=Double.parseDouble(textAnswer.getText());}//按下'Backspace'键，利用循环将当前字符串中的最后一个字母删除if (temp == buttonBk && clickable == true) { String s = textAnswer.getText();textAnswer.setText("");for (int i = 0; i < s.length() - 1; i++) {char a = s.charAt(i);textAnswer.setText(textAnswer.getText() + a);}}//按下'CE'按钮，将当前文本框内数据清除if (temp == buttonCe) {textAnswer.setText("");clickable = true;}//按下'C'按钮，文本框内数据清除，同时var,answer清0if (temp == buttonC) {vard = answerd = 0;textAnswer.setText("");clickable = true;}}//输入中如果有操作非法，比如按下两次'+'，捕获异常catch (Exception e) {textAnswer.setText("操作非法");clickable = false;}}//主函数public static void main(String args[]) {new jsq();}}五、程序运行结果演示计算器界面7+8清除9-47*88/4储存使用储存值清除储存值2的倒数5的百分9的开方六、总结通过本次实验让我对JFrame类、JPanel类、5种布局管理器、文本框、标签及按钮的使用方法，有了进一步的了解。

java课程设计-计算器Word版

Java 程序设计课程设计报告( 2011 -- 2012 年度第 1 学期)计算器专业计算机科学与技术（网络工程）学生姓名赵宝文班级 B 计算机102 学号1010704227 指导教师徐森完成日期2012年1月8日目录目录 (2)1 概述 (1)1.1 课程设计目的 (1)1.2 课程设计内容 (1)2 系统需求分析 (1)2.1 系统目标 (1)2.2 主体功能 (1)2.3 开发环境 (1)3 系统概要设计 (1)3.1 系统的功能模块划分 (1)3.2 系统流程图 (2)4系统详细设计 (2)4.1 COMPUTERPAD(主类) (2)4.2 NUMBERBUTTON (2)4.3 OPERATIONBUTTON (3)5 测试 (3)5.1 测试方案 (3)5.2 测试结果 (4)6 小结 (4)参考文献 (5)附录 (6)附录Ⅰ源程序清单 (6)附录Ⅱ源程序清单 (14)附录Ⅲ源程序清单 (14)题目1 概述1.1 课程设计目的1.熟悉Java的运行环境及其使用；2.掌握Java图形界面的使用；3.加强Java程序的分析能力；4.加强使用Java知识解决实际问题的能力。

1.2 课程设计内容设计GUI界面的计算器程序，用户可以通过鼠标依次输入参加计算的数值，进行加、减、乘、除等混合运算。

2 系统需求分析2.1 系统目标要求所设计的GUI界面计算器是一个使用很方便的程序，能进行加、减、乘、除等混合运算。

2.2 主体功能用户可以通过鼠标依次输入参加计算的数值，进行加、减、乘、除等混合运算。

2.3 开发环境Eclipse集成开发环境3 系统概要设计3.1 系统的功能模块划分本计算机文件共有3个java源文件。

类之间的主要关系如下图所示ComputerPad.java该java源文件生成的类负责创建计算器的“主窗口”。

该类含有main方法，整个程序从该类开始执行。

NumberButton.java该文件生成的类负责为主类创建数字按钮对象，使用鼠标单击数字按钮可依次输入参加运算的数值的各位数字。

Java程序设计实验1(计算器)报告.doc

中南民族大学计算机科学学院Java程序设计实验一报告2014—2015第二学期课程名称： Java程序设计院系：计算机科学学院年级： 2013 专业：计算机科学与技术班级： 1大班小组成员(学号姓名)：201321091035 高波 201321091071 王吉201321151065 锁松源指导教师：强小利2015年5月实验一Java 计算器编程1. 实验类型：设计型2. 实验目的（1）熟悉Java编程环境JDK和NetBeans的安装，配置和使用；（2）掌握Java Application的编写及调试；（3）掌握Java图形用户界面的设计及其编程；（4）熟练掌握Java的事件委托处理模型；（5）熟练掌握java.awt包常用类的使用；（6）掌握Java的封装、继承和多态程序设计。

3. 实验任务利用Java编程技术实现一个简单的计算器，具体要求如下：（1）编写一个Java Application，使得程序能提供计算器的一般计算功能，计算器界面如下：（2）使用java.awt.Frame创建一个窗框。

（3）为计算器的每个按钮(button)注册监听器。

（4）利用FlowLayout、BorderLayout、GridLayout设置容器的布局。

（5）利用容器间的嵌套策略来布置整个计算器的界面，充分利用Panel作为中间层容器的优点。

（6）对于带括号的表达式，能够根据优先次序求解表达式的值。

以下为选做功能：（7）能够对大整数进行运算。

4. 组内分工(说明每个成员分工的编程工作)王吉主要负责实现计算器的基本功能包括加减乘除四则运算、倒数、平方根及清除结果等功能。

高波负责通过图形界面设计，掌握JFrame类、JPanel类、5种布局管理器、文本框、标签及按钮的使用方法。

锁松原负责按钮监听，计算器的每个按钮(button)注册监听器。

5. Java源代码import java.awt.*;import java.awt.event.*;import java.util.Stack;import javax.swing.*;public class Calculator extends JFrame implements ActionListener{private JTextField txtResult;private JPanel p;private String name[] = { "7", "8", "9", "+", "4", "5", "6", "-","1", "2", "3", "*", "0", ".", "=", "/", "π", "C", "(", ")" };private JButton button[] = new JButton[name.length];private JMenuBar menuBar;//菜单栏的实现。

用JAVA编写的计算器程序设计报告

目录目录 (1)1 需求分析 (1)1.1 计算器的基本功能： (2)1.1.1 加法运算：用数字按钮和“+”按钮进行运算； (2)1.1.2 减法运算：用数字按钮和“-”按钮进行运算； (2)1.1.3 乘法运算：用数字按钮和“*”按钮进行运算； (2)1.1.4 除法运算：用数字按钮和“/”按钮进行运算； (2)1.2 退格键和清零键: 用”Backspace”和”C”按钮实现; (2)1.3 计算器的科学计算方法： (2)1.3.1 开方：用数字按钮和“Sqrt”按钮进行运算； (2)1.3.2 百分比：用数字按钮和“%”按钮进行运算； (2)1.3.3 求倒数：用数字按钮和“1/x”按钮进行运算； (2)2 设计 (2)2.1 用户界面设计 (2)2.1.1 该计算器程序的设计：用户界面包括Swing组件,不过程序中大都使用的是AWT组件. import java.awt.*; (3)2.1.2 在AWT组件, (3)2.1.3 这个界面设计中包含了两个接口,单击事件监听器接ActionListener口和键盘事件监听器接口(KeyListener). (4)2.1.4 程序设计中,使用了布局管理: (5)2.2 概要设计 (5)2.2.1 Calculator类中的类名是Calculator.它的功能是使用图形用户来实现计算器的界面设计和运算功能以及一些科学运算方法. (5)2.2.2 main主类.中调用了cal.display来实现计算器的功能 . (5)3 实现 (5)4 测试 (17)4.1 实现加法运算：4+12=16 (18)4.2 实现减法运算：22-11=11 (18)4.3 实现乘法运算：3*9=27 (19)4.4 实现除法运算：64/32=2 (19)4.5 用”C’实现清零功能: (20)4.6 用”Backspace”实现退格功能: (21)4.7 求倒数:1/4=0.25 (21)5 总结和体会............................................................................................................... 错误!未定义书签。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

JA V A课程设计之计算器设计报告含源代码|计算机数据库课程设计|精品课程网站设计|课程设计网报告总结心得本计算器可以进行简单的四则运算（加、减、乘、除）但仅限于十进制下，还可以进行（八进制，十进制，十六进制）之间的相互转换，八进制最多可以输入19位数，十进制最多可以输入18位数，十六进制最多可以输入14位数,backspace表示退格, clear 表示初始化，在window下直接运行（Jsp2003.bat）即可，界面为灰白对称。

题目：计算器目录1．摘要2．概要设计3．详细设计4．测试分析5．参考文献一、摘要本计算器可以进行简单的四则运算（加、减、乘、除）但仅限于十进制下，还可以进行（八进制，十进制，十六进制）之间的相互转换，八进制最多可以输入19位数，十进制最多可以输入18位数，十六进制最多可以输入14位数,backspace表示退格, clear表示初始化，在window下直接运行（Jsp2003.bat）即可，界面为灰白对称。

二、概要设计（1）自定义类说明*********************************************************** 类名: This_number_too_big ** 作用: 自定义的异常类，用来处理计算结果溢出 ** 继承的父类: Exception类 ** 实现的接口: 没有 ***********************************************************class This_number_too_big extends Exception{}//自定义的一个结果溢出异常类*********************************************************** 类名: Jsp2003 ** 作用: 主类。

** 继承的父类: Frame类 ** 实现的接口: ItemListener类,ActionListener类 ***********************************************************class Jsp2003 extends Frame implements ItemListener,ActionListener{public int number=0,length=18;//number是用来记录输入的数字个数，//length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制 public char mark='n';//设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’public double data=0;//设置运算数据为零public char ch;//用来临时存放所按按钮的第一个字符public boolean Refresh=false;//设置lab是否要在输入数据的时候刷新，初始为否主要方法说明：------------------------------------------------------------------------------------------------//用来处理按了运算符后的计算-public void js() throws This_number_too_big //指定由method抛出异常{if (mark=='n') //没有运算符{mark=ch; //，则设置运算符为刚刚输入的字符，data=Double.parseDouble(lab.getText());//则设置运算数据为lab的值Refresh=true;//则设置下一次输入的时候要刷新lab}else //如果采用的是连续运算（即没有使用‘=’号）则运行下面的语句{switch (mark) //根据运算符计算结果，并把结果保存到data{ case '+': data+=Double.parseDouble(lab.getText()); break;case '-': data-=Double.parseDouble(lab.getText()); break;case '*': data*=Double.parseDouble(lab.getText()); break;case '/': data/=Double.parseDouble(lab.getText()); break;}lab.setText(Double.toString(data)); //显示运算结果mark=ch;//设置运算符为刚刚按下的运算符Refresh=true;//则设置下一次输入的时候要刷新labnumber=lab.getText().length();//设置输入的字符个数// System.out.println(lab.getText());//用来调试用的if (data>Double.MAX_VALUE)//如果data超过double类型的最大值则抛出自定义的一个异常类{throw new This_number_too_big(); }}}//end js() method----------------------------------------------------------------------------------------------------public void enter()//处理输入字符{if(Refresh==true)//如果已经设置了运算符则在下一次输入数据的时候要把以前lab的内容清除掉{lab.setText("0"); number=0; Refresh=false;}if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)//如果lab的内容为0则，lab的内容将被所输入的字符代替，//否则直接在lab的内容后面加上所输入的字符{lab.setText(Character.toString(ch)); number++;}elseif(number{number++;lab.setText(lab.getText()+ch);}}//end enter() method--------------------------------------------------------------------------------------------------------//八进制或十六进制转换成十进制Ipublic String goto_10(String s,long l)//参数s：是要转换的字符串，由于输入的控制，保证了字符串的合法性；//参数l：使用来设置是将8进制还是16进制转换成10进制，它的有效值为8或16；{ String str=s; //用来转换的字符串long j=l; //表示进制long lg=0,jing=1;//lg用来记录权乘和，jing用来记录位权char cha;//临时记录要转换的字符for(int i=1;i<=str.length();i++){ cha=str.charAt(str.length()-i);switch(cha){ case '1': lg=lg+1*jing;break;case '2': lg=lg+2*jing;break;case '3': lg=lg+3*jing;break;case '4': lg=lg+4*jing;break;case '5': lg=lg+5*jing;break;case '6': lg=lg+6*jing;break;case '7': lg=lg+7*jing;break;case '8': lg=lg+8*jing;break;case '9': lg=lg+9*jing;break;case 'A': lg=lg+10*jing;break;case 'B': lg=lg+11*jing;break;case 'C': lg=lg+12*jing;break;case 'D': lg=lg+13*jing;break;case 'E': lg=lg+14*jing;break;case 'F': lg=lg+15*jing;break;}jing*=j; //位权升一级，为下次使用做好准备}return Long.toString(lg);}//end String goto_10() method}（2）程序流程图三、详细设计import java.awt.*;import java.awt.event.*;class This_number_too_big extends Exception{}//自定义的一个结果溢出异常类class Jsp2003 extends Frame implements ItemListener,ActionListener {public Jsp2003() {addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {dispose();System.exit(0);}});}static Jsp2003 mainFrame = new Jsp2003();static Label lab=new Label("0");static Panel pnl1=new Panel(new GridLayout(4,3,3,3));static Panel pnl2=new Panel(new GridLayout(4,1,3,3));static Panel pnl3=new Panel(new GridLayout(1,2,3,3));static Panel pnl4=new Panel(new GridLayout(6,1,3,3));static Button bt9=new Button("9");static Button bt8=new Button("8");static Button bt7=new Button("7");static Button bt6=new Button("6");static Button bt5=new Button("5");static Button bt4=new Button("4");static Button bt3=new Button("3");static Button bt2=new Button("2");static Button bt1=new Button("1");static Button bt0=new Button("0");static Button btdot=new Button(".");static Button btequ=new Button("=");static Button btadd=new Button("+");static Button btsub=new Button("-");static Button btmul=new Button("*");static Button btdev=new Button("/");static Button btA=new Button("A");static Button btB=new Button("B");static Button btC=new Button("C");static Button btD=new Button("D");static Button btE=new Button("E");static Button btF=new Button("F");static Checkbox ckb8=new Checkbox("八进制");static Checkbox ckb10=new Checkbox("十进制");static Checkbox ckb16=new Checkbox("十六进制");static Button btc=new Button("clear");static Button btt=new Button("backspace");public int number=0,length=18;//number是用来记录输入的数字个数，length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制public char mark='n'; //设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’ public double data=0; //设置运算数据为零public char ch; //用来临时存放所按按钮的第一个字符public boolean Refresh=false;//设置lab是否要在输入数据的时候刷新，初始为否public static void main(String args[]) {System.out.println("Starting Jsp2003...");lab.setAlignment(Label.RIGHT);lab.setBackground(Color.lightGray);lab.setForeground(Color.BLUE);lab.setFont(new Font("Serief",Font.BOLD,18));lab.setBounds(14,33,216,40);mainFrame.add(lab);CheckboxGroup grp=new CheckboxGroup();ckb8.setCheckboxGroup(grp);ckb10.setCheckboxGroup(grp);ckb16.setCheckboxGroup(grp);ckb8.setBounds(14,75,55,25);ckb10.setBounds(69,75,55,25);ckb16.setBounds(124,75,65,25);ckb8.setState(false);ckb10.setState(true);ckb16.setState(false);mainFrame.add(ckb8);mainFrame.add(ckb10);mainFrame.add(ckb16);pnl1.setBounds(14,140,120,150);pnl2.setBounds(144,140,40,150);pnl3.setBounds(14,100,170,36);pnl4.setBounds(190,100,40,190);pnl1.add(bt7);pnl1.add(bt8);pnl1.add(bt9);pnl1.add(bt4);pnl1.add(bt5);pnl1.add(bt6);pnl1.add(bt1);pnl1.add(bt2);pnl1.add(bt3);pnl1.add(bt0);pnl1.add(btdot);pnl1.add(btequ);pnl2.add(btadd);pnl2.add(btsub);pnl2.add(btmul);pnl2.add(btdev);pnl3.add(btt);pnl3.add(btc);pnl4.add(btA);pnl4.add(btB);pnl4.add(btC);pnl4.add(btD);pnl4.add(btE);pnl4.add(btF);btA.enable(false);btB.enable(false);btC.enable(false)；btD.enable(false);btE.enable(false);btF.enable(false);mainFrame.add(pnl1);mainFrame.add(pnl2);mainFrame.add(pnl3);mainFrame.add(pnl4);mainFrame.setResizable(false); mainFrame.setLayout(null); mainFrame.setSize(240,300 ); mainFrame.setTitle("计算器"); mainFrame.setVisible(true);ckb8.addItemListener(mainFrame); ckb10.addItemListener(mainFrame); ckb16.addItemListener(mainFrame); //把事件聆听者向各个组键注册bt1.addActionListener(mainFrame); bt2.addActionListener(mainFrame); bt3.addActionListener(mainFrame); bt4.addActionListener(mainFrame); bt5.addActionListener(mainFrame); bt6.addActionListener(mainFrame); bt7.addActionListener(mainFrame); bt8.addActionListener(mainFrame); bt9.addActionListener(mainFrame); bt0.addActionListener(mainFrame); btadd.addActionListener(mainFrame); btsub.addActionListener(mainFrame); btmul.addActionListener(mainFrame); btdev.addActionListener(mainFrame); btt.addActionListener(mainFrame); btc.addActionListener(mainFrame);btdot.addActionListener(mainFrame);btequ.addActionListener(mainFrame);btA.addActionListener(mainFrame);btB.addActionListener(mainFrame);btC.addActionListener(mainFrame);btD.addActionListener(mainFrame);btE.addActionListener(mainFrame);btF.addActionListener(mainFrame);}// end main() mothed//---------------------------------------------//checkbox 事件的处理public void itemStateChanged(ItemEvent e){ mark='n';Refresh=false;//规定当进制转换时以前输入的运算符失效if (ckb8.getState()==true){ btA.enable(false);btB.enable(false);btC.enable(false);btD.enable(false);btE.enable(false);btF.enable(false);bt9.enable(false);bt8.enable(false);btdot.enable(false);btadd.enable(false);btmul.enable(false);btsub.enable(false);btdev.enable(false);btequ.enable(false);//在八进制的情况下对有些按件的管理if(length==18) { lab.setText(goto10_8(lab.getText())); number=lab.getText().length();}if(length==14) { lab.setText(goto_10(lab.getText(),16L)); lab.setText(goto10_8(lab.getText()));number=lab.getText().length();}//将其他进制转换成八进制length=19;//在八进制下允许输入数字个数最多为19位}if(ckb10.getState()==true){ btA.enable(false);btB.enable(false);btC.enable(false);btD.enable(false);btE.enable(false);btF.enable(false);bt9.enable(true);bt8.enable(true);btdot.enable(true);btadd.enable(true);btmul.enable(true);btsub.enable(true);btdev.enable(true);btequ.enable(true);//在十进制的情况下对有些按件的管理if(length==19) { lab.setText(goto_10(lab.getText(),8L)); number=lab.getText().length();}if(length==14) { lab.setText(goto_10(lab.getText(),16L)); number=lab.getText().length();}//进制转换成十进制length=18;//在十进制下允许输入数字个数最多为18位}if(ckb16.getState()==true){ btA.enable(true);btB.enable(true);btC.enable(true);btD.enable(true);btE.enable(true);btF.enable(true);bt9.enable(true);bt8.enable(true);btdot.enable(false);btadd.enable(false);btmul.enable(false);btsub.enable(false);btdev.enable(false);btequ.enable(false);//在十六进制的情况下对有些按件的管理if(length==18) { lab.setText(goto10_16(lab.getText())); number=lab.getText().length();}if(length==19) { lab.setText(goto_10(lab.getText(),8L));lab.setText(goto10_16(lab.getText()));number=lab.getText().length();}//将其他进制转换成十六进制length=14;//在十六进制下允许输入数字个数最多为14位}//end itemStateChanged(ItemEvent e) method//------------------------------------------------------------//按钮事件的处理public void actionPerformed(ActionEvent m){Button btn=(Button) m.getSource();ch=btn.getLabel().charAt(0);switch (ch){ case 'c': {lab.setText("0"); number=0; mark='n'; Refresh=false;}break;//初始化case '1': enter(); break;case '2': enter(); break;case '3': enter(); break;case '4': enter(); break;case '5': enter(); break;case '6': enter(); break;case '7': enter(); break;case '8': enter(); break;case '9': enter(); break;case '0': {if(Refresh==true) { lab.setText("0"); number=0; Refresh=false; }if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)break;if(number{number++;lab.setText(lab.getText()+ch);} else break;} break;case 'A': enter(); break;case 'B': enter(); break;case 'C': enter(); break;case 'D': enter(); break;case 'E': enter(); break;case 'F': enter(); break;case '.': {if(Refresh==true) {lab.setText("0"); number=0; Refresh=false;}if(lab.getText().indexOf('.')== -1){number++;lab.setText(lab.getText()+ch);}elsebreak;}break;case 'b': {if(number==0) break;else{if(--number==0) {lab.setText("0"); number=0;}else{if (number!=1) lab.setText(lab.getText().substring(0,number)); elselab.setText(Character.toString(lab.getText().charAt(0)));}}}break;case '+': try{ js();}catch(This_number_too_big e){lab.setText("0"); number=0; mark='n';Refresh=false; System.out.println("The number is too big");} break; //如果出现异常则初始化效果如同clear键case '-': try{ js();}catch(This_number_too_big e){lab.setText("0"); number=0; mark='n';Refresh=false; System.out.println("The number is too big");} break; //如果出现异常则初始化效果如同clear键case '*': try{ js();}catch(This_number_too_big e){lab.setText("0"); number=0; mark='n';Refresh=false; System.out.println("The number is too big");} break; //如果出现异常则初始化效果如同clear键case '/': try{ js();}catch(This_number_too_big e){lab.setText("0"); number=0; mark='n';Refresh=false; System.out.println("The number is too big");} break; //如果出现异常则初始化效果如同clear键case '=': try{ js();}catch(This_number_too_big e){lab.setText("0"); number=0; mark='n';Refresh=false; System.out.println("The number is too big");} break; //如果出现异常则初始化效果如同clear键}}//end actionPerformed(ActionEvent e) method//八进制或十六进制转换成十进制I//-------------------------------------Infinitypublic String goto_10(String s,long l)//参数s：是要转换的字符串，由于输入的控制，保证了字符串的合法性；//参数l：使用来设置是将8进制还是16进制转换成10进制，它的有效值为8或16；{String str=s; //用来转换的字符串long j=l; //表示进制long lg=0,jing=1;//lg用来记录权乘和，jing用来记录位权char cha;//临时记录要转换的字符for(int i=1;i<=str.length();i++){cha=str.charAt(str.length()-i);switch(cha){case '1': lg=lg+1*jing;break;case '2': lg=lg+2*jing;break;case '3': lg=lg+3*jing;break;case '4': lg=lg+4*jing;break;case '5': lg=lg+5*jing;break;case '6': lg=lg+6*jing;break;case '7': lg=lg+7*jing;break;case '8': lg=lg+8*jing;break;case '9': lg=lg+9*jing;break;case 'A': lg=lg+10*jing;break;case 'B': lg=lg+11*jing;break;case 'C': lg=lg+12*jing;break;case 'D': lg=lg+13*jing;break;case 'E': lg=lg+14*jing;break;case 'F': lg=lg+15*jing;break;}jing*=j; //位权升一级，为下次使用做好准备}return Long.toString(lg);}//end String goto_10() method//十进制转换成十六进制//-------------------------------------public String goto10_16(String s)//参数s：是要转换的字符串，由于输入的控制，保证了字符串的合法性；{ String str=s; //用来转换的字符串String st=new String();//用来记录16进制值的字符串long ch; //每次取余有的值int k; //将每次取余有的值转换成整形，用来选择转换的16进制字符long lg;//用来转换的10进制数if(str.charAt(0)=='-') //如果有负号则出去负号str=str.substring(1,str.length()-1);if(str.indexOf('E')!= -1)//如果是科学计数值则出去小数点和E后面的数str=str.charAt(0)+str.substring(2,str.indexOf('E'));if (str.indexOf('.')!= -1)//如果有小数点则出去小数点及小数点后面的内容str=str.substring(0,str.indexOf('.'));lg=Long.parseLong(str);//将简化的字符串转化为长整形给lgwhile (lg>=16){ ch=lg%16;k=(int)ch;switch (k){case 10: st="A"+st;break;case 11: st="B"+st;break;case 12: st="C"+st;break;case 13: st="D"+st;break;case 14: st="E"+st;break;case 15: st="F"+st;break;default: st=Long.toString(ch)+st;}lg=lg/16;}k=(int)lg;switch (k){case 10: st="A"+st;break;case 11: st="B"+st;break;case 12: st="C"+st;break;case 13: st="D"+st;break;case 14: st="E"+st;break;case 15: st="F"+st;break;default: st=Long.toString(lg)+st;}return st;}//end goto10_16() method//-----------------------------------------------//十进制转换成八进制?public String goto10_8(String s)//参数s：是要转换的字符串，由于输入的控制，保证了字符串的合法性；{ String str=s;String st=new String();long j=8,ch;long lg;if(str.charAt(0)=='-') //如果有负号则出去负号str=str.substring(1,str.length()-1);if(str.indexOf('E')!= -1)//如果是科学计数值则出去小数点和E后面的数str=str.charAt(0)+str.substring(2,str.indexOf('E'));if (str.indexOf('.')!= -1)//如果有小数点则出去小数点及小数点后面的内容str=str.substring(0,str.indexOf('.'));lg=Long.parseLong(str);while (lg>=j){ ch=lg%j;st=Long.toString(ch)+st;lg=lg/j;}st=Long.toString(lg)+st;return st;}//end goto10_8() method//--------------------------------//输入字符public void enter(){if(Refresh==true)//如果已经设置了运算符则在下一次输入数据的时候要把以前lab的内容清除掉{lab.setText("0"); number=0; Refresh=false;}if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)//如果lab的内容为0则，lab的内容将被所输入的字符代替，否则直接在lab的内容后面加上所输入的字符{lab.setText(Character.toString(ch)); number++;}elseif(number{number++;lab.setText(lab.getText()+ch);}}//end enter() method//-------------------------------------//用来处理按了运算符后的计算-public void js() throws This_number_too_big //指定由method抛出异常{if (mark=='n') //没有运算符{mark=ch; //，则设置运算符为刚刚输入的字符，data=Double.parseDouble(lab.getText());//则设置运算数据为lab的值Refresh=true;//则设置下一次输入的时候要刷新lab}else //如果采用的是连续运算（即没有使用‘=’号）则运行下面的语句{switch (mark) //根据运算符计算结果，并把结果保存到data{ case '+': data+=Double.parseDouble(lab.getText()); break;case '-': data-=Double.parseDouble(lab.getText()); break;case '*': data*=Double.parseDouble(lab.getText()); break;case '/': data/=Double.parseDouble(lab.getText()); break;}lab.setText(Double.toString(data)); //显示运算结果mark=ch;//设置运算符为刚刚按下的运算符Refresh=true;//则设置下一次输入的时候要刷新labnumber=lab.getText().length();//设置输入的字符个数// System.out.println(lab.getText());//用来调试用的if (data>Double.MAX_VALUE)//如果data超过double类型的最大值则抛出自定义的一个异常类{throw new This_number_too_big(); }}}//end js() method//---------------------------//public void answer() throws This_number_too_big //指定由method抛出异常{if (mark=='n'){}else{switch (mark){case '+': data+=Double.parseDouble(lab.getText()); break;case '-': data-=Double.parseDouble(lab.getText()); break;case '*': data*=Double.parseDouble(lab.getText()); break;case '/': data/=Double.parseDouble(lab.getText()); break;}lab.setText(Double.toString(data));mark='n';}if (data>Double.MAX_VALUE) //如果data超过double类型的最大值则抛出自定义的一个异常类{throw new This_number_too_big();}Refresh=false;number=lab.getText().length();}//end answer() method//---------------------------}//end class Jsp20034．测试分析（1）程序运行情况:程序正常的响应按钮事件，输入的数值长度受变量length的限定，进行混合四则运算的时候，结果如果不是很大，可以正常显示，但如果结果很大，就可能采用科学记数方式，这样带来了进制转换时的麻烦，需要特殊的处理科学记数里的E ，当结果太大的时候，有可能超出可能表示的最大值，（结果溢出），这个时候就要对结果进行必要的异常处理，我在输出结果的方法内设置if 语句，如果结果大于某一个值就抛出一个This_number_too_big 类型的类，再使用try-catch，捕捉输出结果的方法抛出的异常对象。