简单计算器设计java课程.doc

存档资料 成绩：　

华东交通大学理工学院
课 程 设 计 报 告 书

所属课程名称 Java语言程序设计
题 目 　 　简单计算器设计　 　　　
分 院 　　 电 信 分 院 　　 　
专业班级 12通信工程1班
学　　号 20120210420112 　 　　　　 　　 　
学生姓名 　 　　　
指导教师 　　　

2014 年 6 月 20日
华东交通大学理工学院课程设计报告
目　录
第1章 计算器机要求与内容........................................... 3
第2章 计算器设计............................................................. 4
第3章 计算器程序代码...................................................14
第4章 计算器测试.............................................................49
第5章 课程设计心得.........................................................53
第6章 参考文献..................................................................54第1章 计算器内容及要求
一 设计内容：
1. 实现基本的加减乘除法的运算；
2 实现常用的函数计算功能；
3. 实现将系统时间在界面上显示；
4. 实现菜单对计算器的关闭、开启及设置运算法则的操作。
二 设计要求
1. 使用菜单控制计算器界面的显示，关闭；
2. 使用菜单控制运算的法则；
3. 使用菜单显示函数运算窗口及运算；
4. 数据采用手工输入方式；
5. 对异常的数据进行异常处理，比如1/0的情况。

第2章 计算器设计
一．设计模式
采用MVC设计模式，将模型，视图，控制分别单独完成。在模型中将视图，控制添加到其中，再分别完成视图的，控制的程序。
二．结构设计
在界面中分为四个视图的组件，控制分为按钮事件，菜单选择事件，以及键盘输入控制事件。如图1
模型
时间布
局组件

操作模式
布局组件
函数运算组件
结果布
局组件
按钮
事件
菜单选
择事件
键盘输
入事件
菜单布
局组件

运算布
局组件

图1
在界面的布局上采用网格布局，将分别装填时间布局组件，操作模式布局组件，运算布局组件，结果布局组件。如图3
组件上的相对应控件相应的事件分别封装按钮事件，菜单项选择事件，键盘输入事件。选择相应的控件，产生对应的响应事件。各组件对应控件的响应事件对应如图2。
运算布
局组件
结果布
局组件
按钮
事件
菜单选
择事件
键盘输
入事件
菜单布
局组件

图2
函数运算组件

图3
三．代码设计
本程序共有六个包wgr.constant，wgr.entry, wgr.event，wgr.layout，wgr.otherlayout，wgr.thread。分别用来盛装各个组件，如图4。

图4
（1）wgr.constant包中有一个Constant类用来盛放程序设计中用到的字符串常量。
例如：加法，减法，乘法及运算符号等。 详见代码。

（2）wgr.entry包中有个一Entry类，此类是程序的入口，也是程序的模型，所有的组件都加载到这里。
此类中定义了两个方法main和loadwidge。Loadwidge的方法获取各个组件中的控件。然后在主方法中对获得的控件添加对应的事件处理机制。例如JButton的点击事件，菜单选择菜单项等。 详见代码。

（3）wgr.event包中含有四个类分别是MyButtonLisener、MyKeyPress、
MyMenu_1_Listner、MyMenu_2_listener。MyButtonLisener作用是按钮的点击响应，MyKeyPress作用是键盘输入数据控制的作用，防止非法的输入，MyMenu_1_Listner的作用是对计算器菜单进行选择的响应，MyMenu_2_listener的作用是对运算模式菜单进行选择的响应，MyMenu_3_listener是对选择运算函数的监听相应。

MyButtonLisener中对运算组件中的“运算”按钮与返回结果组件中的“清除”按钮进行做对应的相应。此类中带有一个MyButtonLisener的有参数构造函数，从Entry类中得到需要操作的控件，比如获得输入框的数据，获得运行模式等。继承了ActionListener接口，实现了actionPerformed方法，在响应“运算”按钮时对输入的数据进行了判断，判断是否可以进行运算，比如数据的不完整，在除法时不能除以0的情况进行了处理。 详见代码。
下面是点击运行时对输入的数据进行判断是否为空，当不为空时再根据计算模式进行计算。
if ((textField_shuru1.getText().toString() != null)
&& (textField_shuru1.getText().toString() != null))
当有空时将有提示对话框
else {
JOptionPane.showMessageDialog(jFrame, "输入的数据不可以为空", "警告",
JOptionPane.OK_OPTION);
}

在进行除法的运算是，会判断被除数是否为零，如果是会弹出一个提示对话框
//运算除法时需要对输入的数据进行处理，判断是否不能进行运算
if (simble.equals(Constant.DIVISION)) {
if (shuru2 != 0.0) {
textField_jieguo.setText(String.valueOf(shuru1
/ shuru2));
} else {
JOptionPane
.showConfirmDialog(jFrame, "输入有误，不可以除以 0",
"提示", JOptionPane.OK_OPTION);
}
}

点击“清空”按钮时会将所有的数据清空
else if (e.getSource().equals(button_clear)) { //将数据清空的按钮

textField_shuru1.setText(null);
textField_shuru2.setText(null);
textField_jieguo.setText(null);
}
MyKeyPress是对输入框输入数据进行了处理，阻止非法的输入，此类继承了KeyListener接口，实现了keyPressed方法，此类有一个MyKeyPress含有参数的构造方法，用来获得需要的控件。
详见代码。
//构造函数，获得面板的需要进行操作的控件
public MyKeyPress(JFrame frame, JTextField textField_shuru1,
JTextField textField_shuru2) {
this.frame = frame;
this.textField_shuru1 = textField_shuru1;
this.textField_shuru2 = textField_shuru2;

}
对非法的输入将弹出提示对话框，然后清除非法的输入。
if ((KeyEvent.VK_0 <= e.getKeyChar() && e.getKeyChar() <= KeyEvent.VK_9)
|| (e.getKeyChar() == KeyEvent.VK_BACK_SPACE)
|| (e.getKeyChar() == KeyEvent.VK_ENTER)
|| (e.getKeyChar() == KeyEvent.VK_PERIOD)) {
} else {
JOptionPane.showConfirmDialog(frame, "输入有误", "提示",
JOptionPane.OK_CANCEL_OPTION);

MyMenu_1_Listner是对计算器菜单进行选择的操作事件，此类继承了ActionListener接口，实现actionPerformed了方法。对“开启计算器”，“关闭计算器”，“退出”的菜单项进行了实现。 详见代码。

选择“开启计算器”时，就将运算模式组件，运算组件，返回结果组件的setVisible设为true实现“开启计算器”功能。
if (e.getSource().equals(menuitem_start)) {

//将模板组件隐藏
panel_2_method.setVisible(true);
panel_3_commond.setVisible(true);
panel_4_result.setVisible(true);
menu.setVisible(true);
menu2.setVisible(true);
}
同理，单击“关闭计算器”时，就将运算模式组件，运算组件，返回结果组件的setVisible设为false实现“关闭计算器”功能。
选择“退出”时，将退出程序，同时将获取时间的线程中断。
//退出程序
if (e.getSource().equals(menuItem_exit)) {
TimeThread.setSTATE(false);
jFrame.dispose();
}

MyMenu_2_listener是对计算器的运算法则进行设置，该类继承了ActionListener接口，实现actionPerformed了方法。该类有一个MyMenu_2_listener有参数的构造方法，获得需要操作的显示运算法则的控件及菜单项。 详见代码。

MyMenu_3_listener是对计算器的函数运算进行设置，该类继承了ActionListener接口，实现actionPerformed了方法。该类有一个MyMenu_3_listener有参数的构造方法，获得需要操作菜单项。 详见代码。

（4）wgr.layout包中是组件的布局，其中含有Commond_layout、Model_layout、MyMenu1、 MyMenu2、Result_layout 、Time_layout六个类的布局组件。
Commond_layout是运行数据的组件，其中有JLabel，JTextField，JButton，JPanel 详见代码。

JPanel使用FlowLayout布局，将JLabel，JTextField，JButton加入JPanel中，效果如上图。
Model_layout是显示运行模式的布局组件，Jpanel使用GridLayout的布局，其中有2个JLabel，分别是当前“当前操作模式：”和显示运算法则的JLabel。 详见代码。

MyMenu1、MyMenu2、MyMenu3都是菜单，MyMenu1是“计算器”菜单里面含有“开启计算器”、“关闭计算器”、“退出”的菜单项。MyMenu2是“计算模式”菜单，里面含有“加法”、“减法”、“乘法”、“除法”的菜单项。菜单使用JMenu，菜单项使用JMenuItem。MyMenu3是“函数”菜单，里面含有“sin(x)”、“cos（x）”、“tan（x）”、“ln(x)”、“sqrt(x)”的菜单项。菜单使用JMenu，菜单项使用JMenuItem。 详见代码。

Result_layout是显示运算结果的布局组件，Jpanel使用FlowLayout的布局，Jpanel中加入JLabel、JTextField、JButton的控件。
详见代码。

JLabel是“结果”的控件，JTextField用来显示得到的结果，JButton是“清除”的按钮，作用是将输入的输入与输出的数据清空。
Time_layout 是显示时间的布局组件， Jpanel使用FlowLayout的布局，Jpanel中加入两个JLabel的控件。分别“显示时间”，另一个是将系统的时间显示在另一个JLabel上。 详见代码。

（5）wgr.otherlayout包中含有一个Hanshu_layout的类，该是是显示函数运算的窗口，并且还有输入框的键盘输入监听事件。

还对输入的数据进行的控制。以防止非法的数据输入，运算产生错误。该类是根据获得函数类型进行相应的运算。
public void keyPressed(KeyEvent e) {
if ((KeyEvent.VK_0 <= e.getKeyChar() && e.getKeyChar() <= KeyEvent.VK_9)
|| (e.getKeyChar() == KeyEvent.VK_BACK_SPACE)
|| (e.getKeyChar() == KeyEvent.VK_ENTER)
|| (e.getKeyChar() == KeyEvent.VK_PERIOD)) {
if (e.getKeyChar() == KeyEvent.VK_PERIOD) {
} else if (!field.getText().toString().equals(null)
&& (e.getKeyChar() == KeyEvent.VK_ENTER)) {
double d = Double.parseDouble(field.getText()
.toString());
if (MyMenu_3_listener.getString() == Constant.F_Sin) {
field2.setText(String.valueOf(Math.sin(d)).substring(0, 5));
}
if (MyMenu_3_listener.getString() == Constant.F_Cos) {
field2.setText(String.valueOf(Math.cos(d)).substring(0, 5));
}
if (MyMenu_3_listener.getString() == Constant.F_Tan) {
field2.setText(String.valueOf(Math.tan(d)).substring(0, 5));
}
if (MyMenu_3_listener.getString() == Constant.F_Sqrt) {
field2.setText(String.valueOf(Math.sqrt(d)));
}
if (MyMenu_3_listener.getString() == Constant.F_Log) {
field2.setText(String.valueOf(Math.log(d)).substring(0, 5));
}
} else if (e.getKeyChar() == KeyEvent.VK_BACK_SPACE) {
field.setText(null);
field2.setText(null);
}
;

} else {
JOptionPane.showConfirmDialog(frame, "输入有误", "提示",
JOptionPane.OK_CANCEL_OPTION);

// 如果输入了非法的数据，将非法输入的数据删除掉
field.setText(field
.getText()
.toString()
.substring(0,
field.getText().toString().length() - 1));
}
}

（6）wgr.thread包中只含有一个TimeThread类，该类继承了Thread。该类有一个TimeThread有参数的构造方法，用来获得Time_layou中的显示系统时间的Jlabel。
public TimeThread(JLabel label) {
jLabel = label;
}
该类重写了run方法，获得系统的时间，将时间显示获得的jlabel上。

public void run() {
super.run();
while (true) {
//当程序退出时，使此线程中断
if(isSTATE()){
jLabel.setText(time.format(new Date()));
}
else break;

}

}
此类还有一个来获取程序是否推退出的的方法setSTATE，如果程序退出了，将会得到false，线程的run方法就会终止。

public static boolean isSTATE() {
return STATE;
}

public static void setSTATE(boolean sTATE) {
STATE = sTATE;
}

第3章 计算器程序代码
（1）常量包：

Constant.java代码：

（2）模型包，即入口包

Entry.java代码：

（3）响应事件包：

MyButtonLisener. java按钮响应事件：
MyKeyPress.java键盘输入事件：
MyMenu_1_Listner.java计算机菜单选择事件：
MyMenu_2_listener.java操作模式菜单选择事件：
MyMenu_3_listenerjava操作函数运算选择事件：

（4）各个界面布局组件包：

Commond_layout.java运算布局组件：
Model_layout.java显示运算模式布局组件：
MyMenu1.java计算器菜单组件：
MyMenu2.java运算模式菜单组件：
MyMenu3.java函数运算菜单组件：
Result_layout.java 运算结果布局组件：
Time_layout.java 显示时间布局组件：
（5）函数运算包

Hanshu_layout.java函数运算窗口：
（6）获取事件线程包：

TimeThread.java 获取时间线程组件：
Constant.java代码： 回到程序目录

package wgr.constant;

public class Constant {

// 菜单一的常量
public static final String COUNTER="计算器";

public static final String START="启动计算器";
public static final String CLOSE="关闭计算器";
public static final String EXIT="退出";

// 运算的常量，也是菜单2的常量
public static final String MODEL="运算模式";

public static final String ADDITION="加法";
public static final String SUBDUCTION="减法";
public static final String MULTIPLICATION="乘法";
public static final String DIVISION="除法";

// 运算模式符号
public static final String ADDITION_SYMBOL="+";
public static final String SUBDUCTION_SYMBOL="—";
public static final String MULTIPLICATION_SYMBOL="*";
public static final String DIVISION_SYMBOL="/";

//函数字符串
public static final String FX="函数";

public static final String F_Cos="Cos(X)";
public static final String F_Sin="Sin(X)";
public static final String F_Tan="Tan(X)";
public static final String F_Log="Ln(X)";
public static final String F_Sqrt="Sqrt(X)";

public static final String F_Cos_SYMBOL="Cos(";
public static final String F_Sin_SYMBOL="Sin(";
public static final String F_Tan_SYMBOL="Tan(";
public static final String F_Log_SYMBOL="Ln(";
public static final String F_Sqrt_SYMBOL="Sqrt(";

}

Entry.java代码： 回到程序目录

package wgr.entry;

import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
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.JTextField;
import wgr.constant.Constant;
import wgr.event.MyButtonLisener;
import wgr.event.MyKeyPress;
import wgr.event.MyMenu_1_Listner;
import wgr.event.MyMenu_2_listener;
import wgr.event.MyMenu_3_listener;
import wgr.layout.Commond_layout;
import wgr.layout.Model_layout;
import wgr.layout.MyMenu1;
import wgr.layout.MyMenu2;
import wgr.layout.MyMenu3;
import wgr.layout.Result_layout;
import wgr.layout.Time_layout;
import wgr.thread.TimeThread;

/**
* 采用MVC的设计方式 这是一个入口也是一个框架,将各个布局加载到这个框架中来,
*
* 菜单包括计算机菜单项组件,计算模式菜单的组件
*
* 包含时间面板的组件,操作模式面板组件,命令面板的组件,返回数据面板的组件
*
* 将各个组件的响应事件放在WGR.EVENT的包中 MyWindowsListner 监听窗口的事件 MyButtonLisener 监听按钮响应的事件,
* MyKeyPress 输入框的键盘事件, MyMenu_1_Listner MyMenu_2_listener 菜单的选择事件.
*
* wgr.constant包中Constant存放一些常量 wgr.layout包中存放各个组件的布局文件
*
* wgr.thread TimeThread 获取系统时间的线程,将系统时间显示在时间面板的组件中.
*/
public class Entry {

private static JFrame frame;

private static JMenuBar menuBar;
private static JMenu menu1, menu2, menu3;
private static JMenuItem menuitem_start, menuItem_close, menuItem_exit,
menu_addition, menu_subduction, menu_multiplication, menu_division,
menu_sin, menu_cos, menu_tan, menu_log, menu_sqrt;

private static JPanel panel_1_time, panel_2_method, panel_3_commond,
panel_4_result;

private static JLabel label_time_data, label_mothod, label_model_symble;

private static JButton button, button_clear;;

private static JTextField textField_shuru1, textField_shuru2,
textField_jieguo;

private static TimeThread timeThead;
private static Time_layout time_layout;
private static Model_layout model_layout;
private static Commond_layout commond_layout;
private static Result_layout result_layout;
private static MyMenu1 myMenu1;
private static MyMenu2 myMenu2;
private static MyMenu3 myMenu3;

public static void main(String[] args) {

menuBar = new JMenuBar();
menu1 = new JMenu(Constant.COUNTER);
menu2 = new JMenu(Constant.MODEL);
menu3 = new JMenu(Constant.FX);

/**
* panel_1_time 时间面板组件 panel_2_method 运算模式面板组件 panel_3_commond
* 输入数据运算面板组件 panel_4_result 运算结果的面板组件
*/
panel_1_time = new JPanel();
panel_2_method = new JPanel();
panel_3_commond = new JPanel();
panel_4_result = new JPanel();

frame = new JFrame(Constant.COUNTER);
frame.setSize(350, 320);
frame.setLocation(
(Toolkit.getDefaultToolkit().getScreenSize().width - 350) / 2,
(Toolkit.getDefaultToolkit().getScreenSize().height - 320) / 2);
frame.setResizable(false);
frame.setLayout(new GridLayout(4, 1));
// 添加菜单1
myMenu1 = new MyMenu1();
menuBar.add(myMenu1.layout(menu1));
// 添加菜单2
myMenu2 = new MyMenu2();
menuBar.add(myMenu2.layout(menu2));
// 添加菜单2
myMenu3 = new MyMenu3();
menuBar.add(myMenu3.layout(menu3));
// 添加菜单条
frame.setJMenuBar(menuBar);
// 添加显示时间组件
time_layout = new Time_layout();
frame.add(time_layout.layout(panel_1_time));
// 添加显示操作模式组件
model_layout = new Model_layout();
frame.add(model_layout.layout(panel_2_method));
// 添加运算命令组件
commond_layout = new Commond_layout();
frame.add(commond_layout.layout(panel_3_commond));
// 添加返回结果组件
result_layout = new Result_layout();
frame.add(result_layout.layout(panel_4_result));

menu2.setVisible(false);
menu3.setVisible(false);
panel_2_method.setVisible(false);
panel_3_commond.setVisible(false);
panel_4_result.setVisible(false);
frame.setVisible(true);
// 加载各个控件
loadwidge();
// 窗口的监听事件
frame.addWindowListener(new WindowAdapter() {

@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
TimeThread.setSTATE(false);
frame.dispose();
}

});
// 添加时间至标签
timeThead = new TimeThread(label_time_data);
timeThead.start();

// 按钮监听事件
MyButtonLisener myButtonLisener = new MyButtonLisener(frame, button,
button_clear, label_mothod, textField_shuru1, textField_shuru2,
textField_jieguo);
button.addActionListener(myButtonLisener);
button_clear.addActionListener(myButtonLisener);

// 建立输入框的输入判断事件
MyKeyPress myKeyPress = new MyKeyPress(frame, textField_shuru1,
textField_shuru2);
textField_shuru2.addKeyListener(myKeyPress);
textField_shuru1.addKeyListener(myKeyPress);

// 添加计算机菜单监听事件
MyMenu_1_Listner menu_1_Listner = new MyMenu_1_Listner(frame,
panel_2_method, panel_3_commond, panel_4_result,
menuitem_start, menuItem_close, menuItem_exit,menu2,menu3);
menuitem_start.addActionListener(menu_1_Listner);
menuItem_close.addActionListener(menu_1_Listner);
menuItem_exi