实验3 Java Swing编程（2学时）

实验目的

1. 掌握Java Swing常用组件的编程方法。
2. 掌握Java事件编程机制。

实验任务

1.多窗口编程：第一个窗口录入学生的基本信息，包括学号、姓名、学院、专业（下拉列表）、班级、籍贯（级联）、性别（单选按钮）、爱好（多选）、简介等，在界面中有提交和重填按钮。提交后打开第二个窗口显示录入的学生信息。

package Student;

/*
多窗口编程：第一个窗口录入学生的基本信息，
包括学号、姓名、学院、专业（下拉列表）、班级、籍贯（级联）、
性别（单选按钮）、爱好（多选）、简介等，
在界面中有提交和重填按钮。
提交后打开第二个窗口显示录入的学生信息。
*/

import javax.swing.*;
import org.jb2011.lnf.beautyeye.*;
import org.jb2011.lnf.beautyeye.ch3_button.BEButtonUI;
import java.awt.*;
import java.awt.event.*;

public class Student  extends JFrame {
	private JFrame jFrame = new JFrame("录入");
	private Container c = jFrame.getContentPane();
	private JLabel a1 = new JLabel("学号");
	private JTextField num = new JTextField();
	private JLabel a2 = new JLabel("姓名");
	private JTextField name = new JTextField();
	private JLabel a3 = new JLabel("学院");
	private JTextField academy = new JTextField();
	private JLabel a4 = new JLabel("专业");
	private JComboBox major = new JComboBox();
	private JLabel a5 = new JLabel("班级");
	private JTextField classes = new JTextField();
	private JLabel a6 = new JLabel("籍贯");
	private JComboBox city = new JComboBox();
	private JComboBox block = new JComboBox();
	private JLabel a7 = new JLabel("性别");
	private JRadioButton boy = new JRadioButton("男生");
	private JRadioButton girl = new JRadioButton("女生");
	private ButtonGroup group = new ButtonGroup();
	private JLabel a8 = new JLabel("爱好");
	private JCheckBox sing = new JCheckBox("唱歌");
	private JCheckBox dance = new JCheckBox("跳舞");
	private JCheckBox draw = new JCheckBox("绘画");
	private JCheckBox code = new JCheckBox("编程");
	private JCheckBox study = new JCheckBox("学习");
	private JLabel a9 = new JLabel("简介");
	private JTextArea brief = new JTextArea("请输入内容", 5, 15);
	private JScrollPane jsp = new JScrollPane(brief); // 将文本域放入滚动窗口
	private JButton submit = new JButton("提交");
	private JButton afresh = new JButton("重填");

	public Student() {
		// 设置窗体的位置及大小
		jFrame.setBounds(60, 200, 420, 550);
		// 设置一层相当于桌布的东西
		c.setLayout(new BorderLayout());// 布局管理器
		// 设置按下右上角X号后关闭
		jFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		// 初始化--往窗体里放其他控件
		init();
		// 设置窗体可见
		jFrame.setVisible(true);
	}

	public void init() {

		/* 标题部分--North */
		JPanel titlePanel = new JPanel();
		titlePanel.setLayout(new FlowLayout());
		titlePanel.add(new JLabel("录入学生的基本信息系统"));
		c.add(titlePanel, "North");
		
		/* 输入部分--Center */
		JPanel fieldPanel = new JPanel();
		fieldPanel.setLayout(null);
		a1.setBounds(100, 20, 50, 20);
		a2.setBounds(100, 50, 50, 20);
		a3.setBounds(100, 80, 50, 20);
		a4.setBounds(100, 110, 50, 20);
		a5.setBounds(100, 140, 50, 20);
		a6.setBounds(100, 170, 50, 20);
		a7.setBounds(100, 200, 50, 20);
		a8.setBounds(100, 230, 50, 20);
		a9.setBounds(100, 320, 50, 20);
		fieldPanel.add(a1);
		fieldPanel.add(a2);
		fieldPanel.add(a3);
		fieldPanel.add(a4);
		fieldPanel.add(a5);
		fieldPanel.add(a6);
		fieldPanel.add(a7);
		fieldPanel.add(a8);
		fieldPanel.add(a9);
		num.setBounds(150, 20, 160, 20);
		name.setBounds(150, 50, 160, 20);
		academy.setBounds(150, 80, 160, 20);
		major.setBounds(150, 110, 160, 20);
		classes.setBounds(150, 140, 160, 20);
		city.setBounds(150, 170, 75, 20);
		block.setBounds(235, 170, 75, 20);
		boy.setBounds(150, 200, 65, 20);
		girl.setBounds(225, 200, 65, 20);
		sing.setBounds(150, 230, 65, 20);
		dance.setBounds(225, 230, 65, 20);
		draw.setBounds(150, 260, 65, 20);
		code.setBounds(225, 260, 65, 20);
		study.setBounds(150, 290, 65, 20);
		Dimension size = brief.getPreferredSize(); // 获得文本域的首选大小
		jsp.setBounds(150, 320, size.width, size.height);
		major.addItem("--请选择--");
		major.addItem("计算机科学与技术");
		major.addItem("软件工程");
		major.addItem("网络工程");
		major.addItem("信息安全");
		city.addItem(" ");
		city.addItem("北京");
		city.addItem("上海");
		city.addItem("武汉");
		city.addItemListener(new ItemListener() {
			@Override
			public void itemStateChanged(ItemEvent arg0) {
				int index = city.getSelectedIndex();
				switch (index) {
				case 0:
					block.removeAllItems();
					break;
				case 1:
					block.removeAllItems();
					block.addItem("西城区");
					block.addItem("东城区");
					block.addItem("崇文区");
					block.addItem("宣武区");
					break;
				case 2:
					block.removeAllItems();
					block.addItem("黄浦区");
					block.addItem("徐汇区");
					block.addItem("长宁区");
					block.addItem("杨浦区");
					block.addItem("虹口区");
					block.addItem("普陀区");
					block.addItem("静安区");
					break;
				case 3:
					block.removeAllItems();
					block.addItem("武昌区");
					block.addItem("洪山区");
					block.addItem("硚口区");
					block.addItem("江岸区");
					block.addItem("江汉区");
					block.addItem("青山区");
					block.addItem("汉阳区");
					break;
				}
			}
		});
		group.add(boy);
		group.add(girl);
		brief.setLineWrap(true); // 设置文本域中的文本为自动换行
		fieldPanel.add(num);
		fieldPanel.add(name);
		fieldPanel.add(academy);
		fieldPanel.add(major);
		fieldPanel.add(classes);
		fieldPanel.add(city);
		fieldPanel.add(block);
		fieldPanel.add(boy);
		fieldPanel.add(girl);
		fieldPanel.add(sing);
		fieldPanel.add(dance);
		fieldPanel.add(draw);
		fieldPanel.add(code);
		fieldPanel.add(study);
		fieldPanel.add(jsp); // 将JScrollPane添加到JPanel容器中
		c.add(fieldPanel, "Center");

		/* 按钮部分--South */
		JPanel buttonPanel = new JPanel();
		buttonPanel.setLayout(new FlowLayout());
		buttonPanel.add(submit);
		submit.setForeground(Color.white);
		submit.setUI(new BEButtonUI().setNormalColor(BEButtonUI.NormalColor.green));
		// 提交按下去获取

		submit.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				String snum = num.getText();
				String sname = String.valueOf(name.getText());
				String sacademy = String.valueOf(academy.getText());
				String smajor = (String) major.getSelectedItem();
				String sclasses = String.valueOf(classes.getText());
				String scity = (String) city.getSelectedItem();
				String sblock = (String) block.getSelectedItem();
				String ssex = "男生";
				if (boy.isSelected())
					ssex = "男生";
				else if (girl.isSelected())
					ssex = "女生";
				 String shobby1="";
                 if(sing.isSelected())
                     shobby1=sing.getText();
                 else
                	 shobby1="";
                 String shobby2="";
                 if(dance.isSelected())
                     shobby2=dance.getText();
                 else
                	 shobby2="";
                 String shobby3="";
                 if(draw.isSelected())
                     shobby3=draw.getText();
                 else
                	 shobby3="";
                 String shobby4="";
                 if(code.isSelected())
                     shobby4=code.getText();
                 else
                	 shobby4="";
                 String shobby5="";
                 if(study.isSelected())
                     shobby5=study.getText();
                 else
                	 shobby5="";
                    String shobby=shobby1+" "+shobby2+" "+shobby3+" "+shobby4+" "+shobby5;
				String sbrief = String.valueOf(brief.getText());

				student2 frame = new student2(snum,sname,sacademy,smajor,sclasses,scity,sblock,ssex,shobby,sbrief); 
				
			}
		});
		
		buttonPanel.add(afresh);
		afresh.setUI(new BEButtonUI().setNormalColor(BEButtonUI.NormalColor.lightBlue));
		afresh.setForeground(Color.white);
		// 重填按下去清空
		afresh.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				num.setText("");
				name.setText("");
				academy.setText("");
				major.setModel(new DefaultComboBoxModel(new String[]{"--请选择--","计算机科学与技术","软件工程","网络工程","信息安全"}));
				classes.setText("");
				city.setModel(new DefaultComboBoxModel(new String[]{" ","北京","上海","武汉"}));
				block.removeAllItems();
				group.clearSelection();
				sing.setSelected(false);
				dance.setSelected(false);
				draw.setSelected(false);
				code.setSelected(false);
				study.setSelected(false);
				brief.setText("");
			}
		});
		c.add(buttonPanel, "South");
	}

	// 测试
	public static void main(String[] args) {
//		String[] DEFAULT_FONT = new String[] { "Table.font", "TableHeader.font", "CheckBox.font", "Tree.font",
//				"Viewport.font", "ProgressBar.font", "RadioButtonMenuItem.font", "ToolBar.font", "ColorChooser.font",
//				"ToggleButton.font", "Panel.font", "TextArea.font", "Menu.font", "TableHeader.font"
//				// ,"TextField.font"
//				, "OptionPane.font", "MenuBar.font", "Button.font", "Label.font", "PasswordField.font",
//				"ScrollPane.font", "MenuItem.font", "ToolTip.font", "List.font", "EditorPane.font", "Table.font",
//				"TabbedPane.font", "RadioButton.font", "CheckBoxMenuItem.font", "TextPane.font", "PopupMenu.font",
//				"TitledBorder.font", "ComboBox.font" };
//		// 调整默认字体
//		for (int i = 0; i < DEFAULT_FONT.length; i++)
//			UIManager.put(DEFAULT_FONT[i], new Font("微软雅黑", Font.PLAIN, 14));
//		
//		/* beautyeye模式 */
//		SwingUtilities.invokeLater(new Runnable() {
//            public void run() {
//                try {
//                	 BeautyEyeLNFHelper.frameBorderStyle = BeautyEyeLNFHelper.FrameBorderStyle.osLookAndFeelDecorated;
//                	org.jb2011.lnf.beautyeye.BeautyEyeLNFHelper.launchBeautyEyeLNF();
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//                Student stu = new Student();
//            }
//        });
		
		/* quaqua模式 */
//        JFrame.setDefaultLookAndFeelDecorated(true);
//		try {
//			UIManager.setLookAndFeel("ch.randelshofer.quaqua.QuaquaLookAndFeel");
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
		Student stu = new Student();
	}

package Student;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.FlowLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;

public class student2 extends JFrame {

	String snum;
	String sname;
	String sacademy;
	String smajor;
	String sclasses;
	String scity;
	String sblock;
	String ssex;
	String shobby;
	String sbrief;

	// 创建新的窗口

	public student2(String snum2, String sname2, String sacademy2, String smajor2, String sclasses2, String scity2,
			String sblock2, String ssex2, String shobby2, String sbrief2) {
		snum = snum2;
		sname = sname2;
		sacademy = sacademy2;
		smajor = smajor2;
		sclasses = sclasses2;
		scity = scity2;
		sblock = sblock2;
		ssex = ssex2;
		shobby = shobby2;
		sbrief = sbrief2;
		// 设置窗体的位置及大小
		jFrame2.setBounds(500, 200, 420, 550);
		// 设置一层相当于桌布的东西
		c2.setLayout(new BorderLayout());// 布局管理器
		// 设置按下右上角X号后关闭
		jFrame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		// 初始化--往窗体里放其他控件
		init();
		// 设置窗体可见
		jFrame2.setVisible(true);
	}

	private JFrame jFrame2 = new JFrame("显示");
	private Container c2 = jFrame2.getContentPane();
	private JLabel show1 = new JLabel("学号：" + snum);
	private JLabel show2 = new JLabel("姓名：" + sname);
	private JLabel show3 = new JLabel("学院：" + sacademy);
	private JLabel show4 = new JLabel("专业：" + smajor);
	private JLabel show5 = new JLabel("班级：" + sclasses);
	private JLabel show6 = new JLabel("籍贯：" + scity + "市" + "，" + sblock);
	private JLabel show7 = new JLabel("性别：" + ssex);
	private JLabel show8 = new JLabel("爱好：" + shobby);
	private JLabel show9 = new JLabel("简介：");
	private JTextArea brief9 = new JTextArea(sbrief, 5, 15);
	private JScrollPane jsp9 = new JScrollPane(brief9);

	public void init() {
		/* 标题部分--North */
		JPanel titlePanel2 = new JPanel();
		titlePanel2.setLayout(new FlowLayout());
		titlePanel2.add(new JLabel("录入学生的基本信息结果显示"));
		jFrame2.getContentPane().add(titlePanel2, "North");
		/* 输入部分--Center */
		JPanel fieldpanel2 = new JPanel();
		jFrame2.getContentPane().add(fieldpanel2);
		fieldpanel2.setLayout(null);
		show1.setBounds(100, 80, 500, 20);
		show2.setBounds(100, 110, 500, 20);
		show3.setBounds(100, 140, 500, 20);
		show4.setBounds(100, 170, 500, 20);
		show5.setBounds(100, 200, 500, 20);
		show6.setBounds(100, 230, 500, 20);
		show7.setBounds(100, 260, 500, 20);
		show8.setBounds(100, 290, 500, 20);
		show9.setBounds(100, 320, 100, 20);
		Dimension size = brief9.getPreferredSize();
		jsp9.setBounds(150, 320, 170, size.height);
		fieldpanel2.add(show1);
		fieldpanel2.add(show2);
		fieldpanel2.add(show3);
		fieldpanel2.add(show4);
		fieldpanel2.add(show5);
		fieldpanel2.add(show6);
		fieldpanel2.add(show7);
		fieldpanel2.add(show8);
		fieldpanel2.add(show9);
		fieldpanel2.add(jsp9);
	}

}

2. 实现一个简单的计算器。界面包括10个数字（0至9）、小数点、4个运算符（加减乘除），以及清空、退格、等号等按钮，还有一个用于显示输入输出的文本框。
   

package Computer;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import org.jb2011.lnf.beautyeye.BeautyEyeLNFHelper;
import org.jb2011.lnf.beautyeye.ch3_button.BEButtonUI;
import java.util.Vector;

public class Calculator extends JFrame {

	// 操作数1，为了程序的安全，初值一定设置。
	String str1 = "0";
	// 操作数2
	String str2 = "0";
	// 运算符
	String signal = "+";
	// 运算结果
	String result = "";

	// 以下k1至k5为状态开关
	// 开关1用于选择输入方向，将要写入str1或str2
	int k1 = 1;
	// 开关2用于记录符号键的次数，如果 k2>1 说明进行的是 2+3-9+8 这样的多符号运算
	int k2 = 1;
	// 开关3用于标识 str1 是否可以被清0 ，等于1时可以，不等于1时不能被清0
	int k3 = 1;
	// 开关4用于标识 str2 是否可以被清0
	int k4 = 1;
	// 开关5用于控制小数点可否被录入，等于1时可以，不为1时，输入的小数点被丢掉
	int k5 = 1;

	// store的作用类似于寄存器，用于记录是否连续按下符号键
	JButton store;

	Vector vt = new Vector(20, 10); // 创建一个向量类对象vt,有20个元素的空间,若空间使用完时,以10个元素空间单位递增。

	// 声明各个UI组件对象并初始化
	JFrame frame = new JFrame("Calculator");
	JTextField result_TextField = new JTextField(result, 20);
	JButton clear_Button = new JButton("Clear");
	JButton button0 = new JButton("0");
	JButton button1 = new JButton("1");
	JButton button2 = new JButton("2");
	JButton button3 = new JButton("3");
	JButton button4 = new JButton("4");
	JButton button5 = new JButton("5");
	JButton button6 = new JButton("6");
	JButton button7 = new JButton("7");
	JButton button8 = new JButton("8");
	JButton button9 = new JButton("9");
	JButton button_Dian = new JButton(".");
	JButton button_jia = new JButton("+");
	JButton button_jian = new JButton("-");
	JButton button_cheng = new JButton("*");
	JButton button_chu = new JButton("/");
	JButton button_dy = new JButton("=");

	// 计算机类的构造器
	public Calculator() {

		// 设置文本框为右对齐，使输入和结果都靠右显示
		result_TextField.setHorizontalAlignment(JTextField.RIGHT);

		// 将UI组件添加进容器内

		JPanel pan = new JPanel();
		pan.setLayout(new GridLayout(4, 4, 5, 5)); // GridLayout(int rows,int cols,int hgap,int
													// vgap);建立一个表格的版面对象。rows代表有几行，cols代表有几列；hgap是组件之间的水平距离，vgap是组件之间的竖直距离。
		pan.add(button7);
		pan.add(button8);
		pan.add(button9);
		pan.add(button_chu);
		pan.add(button4);
		pan.add(button5);
		pan.add(button6);
		pan.add(button_cheng);
		pan.add(button1);
		pan.add(button2);
		pan.add(button3);
		pan.add(button_jian);
		pan.add(button0);
		pan.add(button_Dian);
		pan.add(button_dy);
		pan.add(button_jia);
		pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));// 创建一个框，框的头部为5像素，左为5像素，底部为5像素，右为5像素宽。

		JPanel pan2 = new JPanel();
		pan2.setLayout(new BorderLayout());
		pan2.add(result_TextField, BorderLayout.WEST);
		pan2.add(clear_Button, BorderLayout.EAST);
		clear_Button.setForeground(Color.white);
		clear_Button.setUI(new BEButtonUI().setNormalColor(BEButtonUI.NormalColor.red));

		// 设置主窗口出现在屏幕上的位置
		frame.setLocation(60, 300);

		// 设置窗体不能调大小
		frame.setResizable(false);
		frame.getContentPane().setLayout(new BorderLayout());
		frame.getContentPane().add(pan2, BorderLayout.NORTH);
		frame.getContentPane().add(pan, BorderLayout.CENTER);
		frame.pack();
		frame.setVisible(true);

		// 事件处理程序

		// 数字键
		class Listener implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				String ss = ((JButton) e.getSource()).getText();// 获取数字键的数字
				store = (JButton) e.getSource();
				vt.add(store);
				if (k1 == 1) {// 如果将要写入str1
					if (k3 == 1) {// 如果str1可以被清零
						str1 = "";// 清零str1
						k5 = 1;// 还原开关k5状态，可录入小数点
					}
					str1 = str1 + ss;// 更新str1值
					k3 = k3 + 1;// 开关3用于标识 str1 是否可以被清0 ，等于1时可以，不等于1时不能被清0
					result_TextField.setText(str1);// 显示str1
				} else if (k1 == 2) {// 如果将要写入str2
					if (k4 == 1) {// 如果str2可以被清零
						str2 = "";// 清零str2
						k5 = 1;// 还原开关k5状态，可录入小数点
					}
					str2 = str2 + ss;// 更新str2为button值
					k4 = k4 + 1;// 开关3用于标识 str2 是否可以被清0 ，等于1时可以，不等于1时不能被清0
					result_TextField.setText(str2);// 显示str2
				}
			}
		}

		// 输入的运算符号的处理
		class Listener_signal implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				String ss2 = ((JButton) e.getSource()).getText();
				store = (JButton) e.getSource();
				vt.add(store);
				if (k2 == 1) {// 如果符号键数目为1
					k1 = 2;// 将写入str2
					k5 = 1;// 可以录入小数点
					signal = ss2;// 更新符号
					k2 = k2 + 1;// 更新符号键的次数
				} else {// 如果符号键数目不为1
					int a = vt.size();
					JButton c = (JButton) vt.get(a - 2);// 获取该符号
					if (!(c.getText().equals("+")) && !(c.getText().equals("-")) && !(c.getText().equals("*"))
							&& !(c.getText().equals("/"))) {// 如果符号不是加减乘除
						cal();// 运行计算逻辑
						str1 = result;// 将结果给str1
						k1 = 2;// 将要写入str2
						k5 = 1;// 可以录入小数点
						k4 = 1;// str2可以被清零
						signal = ss2;// 更新符号
					}
					k2 = k2 + 1;// 更新符号键的次数
				}
			}
		}

		// 清除键的逻辑（Clear）
		class Listener_clear implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				store = (JButton) e.getSource();
				vt.add(store);
				// 复位所有
				k5 = 1;
				k2 = 1;
				k1 = 1;
				k3 = 1;
				k4 = 1;
				str1 = "0";
				str2 = "0";
				signal = "";
				result = "";
				result_TextField.setText(result);
				vt.clear();
			}
		}

		// 等于键的逻辑
		class Listener_dy implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				store = (JButton) e.getSource();
				vt.add(store);
				cal();
				// 还原各个开关的状态
				k1 = 1;
				k2 = 1;
				k3 = 1;
				k4 = 1;
				str1 = result;
			}
		}

		// 小数点的处理
		class Listener_xiaos implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				store = (JButton) e.getSource();
				vt.add(store);
				if (k5 == 1) {// 如果小数点可被录入
					String ss2 = ((JButton) e.getSource()).getText();// 获取符号键的符号
					if (k1 == 1) {// 如果将要写入str1
						if (k3 == 1) {// 如果str1可以被清0
							str1 = "";// 清零str1
							k5 = 1;// 还原开关k5状态，可录入小数点
						}
						str1 = str1 + ss2;// 更新str1
						k3 = k3 + 1;// 开关3用于标识 str1 是否可以被清0 ，等于1时可以，不等于1时不能被清0
						result_TextField.setText(str1);// 显示结果
					} else if (k1 == 2) {// 如果将要写入str2
						if (k4 == 1) {// 如果str2可以被清0
							str2 = "";// 清零str2
							k5 = 1;// 还原开关k5的状态，可录入小数点
						}
						str2 = str2 + ss2;
						k4 = k4 + 1;// 开关3用于标识 str2 是否可以被清0 ，等于1时可以，不等于1时不能被清0
						result_TextField.setText(str2);// 显示结果
					}
				}
				k5 = k5 + 1;// 开关5用于控制小数点可否被录入，等于1时可以，不为1时，输入的小数点被丢掉
			}
		}

		// 注册各个监听器，即绑定事件响应逻辑到各个UI组件上

		// 监听等于键
		Listener_dy jt_dy = new Listener_dy();
		// 监听数字键
		Listener jt = new Listener();
		// 监听符号键
		Listener_signal jt_signal = new Listener_signal();
		// 监听清除键
		Listener_clear jt_c = new Listener_clear();
		// 监听小数点键
		Listener_xiaos jt_xs = new Listener_xiaos();

		button7.addActionListener(jt);
		button8.addActionListener(jt);
		button9.addActionListener(jt);
		button_chu.addActionListener(jt_signal);
		button4.addActionListener(jt);
		button5.addActionListener(jt);
		button6.addActionListener(jt);
		button_cheng.addActionListener(jt_signal);
		button1.addActionListener(jt);
		button2.addActionListener(jt);
		button3.addActionListener(jt);
		button_jian.addActionListener(jt_signal);
		button0.addActionListener(jt);
		button_Dian.addActionListener(jt_xs);
		button_dy.addActionListener(jt_dy);
		button_jia.addActionListener(jt_signal);
		clear_Button.addActionListener(jt_c);

		// 窗体关闭事件的响应程序
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
	}

	// 计算逻辑
	public void cal() {
		// 操作数1
		double a2;
		// 操作数2
		double b2;
		// 运算符
		String c = signal;
		// 运算结果
		double result2 = 0;
		if (c.equals("")) {
			result_TextField.setText("请输入运算符号");
		} else {
			// 手动处理小数点的问题
			if (str1.equals("."))
				str1 = "0.0";
			if (str2.equals("."))
				str2 = "0.0";
			a2 = Double.valueOf(str1).doubleValue();
			b2 = Double.valueOf(str2).doubleValue();
			if (c.equals("+")) {
				result2 = a2 + b2;
				result = ((new Double(result2)).toString());
				result_TextField.setText(result);
			}
			if (c.equals("-")) {
				result2 = a2 - b2;
				result = ((new Double(result2)).toString());
				result_TextField.setText(result);
			}
			if (c.equals("*")) {
				result2 = a2 * b2;
				result = ((new Double(result2)).toString());
				result_TextField.setText(result);
			}

			if (c.equals("/")) {
				if (b2 == 0) {
					result_TextField.setText("被除数不能为零");
				} else {
					result2 = a2 / b2;
					result = ((new Double(result2)).toString());
					result_TextField.setText(result);
				}
			}
		}
	}

	public static void main(String[] args) {
//		String[] DEFAULT_FONT = new String[] { "Table.font", "TableHeader.font", "CheckBox.font", "Tree.font",
//				"Viewport.font", "ProgressBar.font", "RadioButtonMenuItem.font", "ToolBar.font", "ColorChooser.font",
//				"ToggleButton.font", "Panel.font", "TextArea.font", "Menu.font", "TableHeader.font"
//				// ,"TextField.font"
//				, "OptionPane.font", "MenuBar.font", "Button.font", "Label.font", "PasswordField.font",
//				"ScrollPane.font", "MenuItem.font", "ToolTip.font", "List.font", "EditorPane.font", "Table.font",
//				"TabbedPane.font", "RadioButton.font", "CheckBoxMenuItem.font", "TextPane.font", "PopupMenu.font",
//				"TitledBorder.font", "ComboBox.font" };
//		// 调整默认字体
//		for (int i = 0; i < DEFAULT_FONT.length; i++)
//			UIManager.put(DEFAULT_FONT[i], new Font("微软雅黑", Font.PLAIN, 14));
//		
//		/* beautyeye模式 */
//		SwingUtilities.invokeLater(new Runnable() {
//			public void run() {
//				try {
//					BeautyEyeLNFHelper.frameBorderStyle = BeautyEyeLNFHelper.FrameBorderStyle.osLookAndFeelDecorated;
//					org.jb2011.lnf.beautyeye.BeautyEyeLNFHelper.launchBeautyEyeLNF();
//				} catch (Exception e) {
//					e.printStackTrace();
//				}
//				Calculator cal = new Calculator();
//			}
//		});
//		
//		/* quaqua模式 */
//        JFrame.setDefaultLookAndFeelDecorated(true);
//		try {
//			UIManager.setLookAndFeel("ch.randelshofer.quaqua.QuaquaLookAndFeel");
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
		Calculator cal = new Calculator();
	}
}

package Computer2;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import Computer2.TurnRPN.ArrStack;
import java.util.Vector;

public class Calculator2 extends JFrame {

	//实时记录按键按的内容
	String str = " ";
	//记录vt中赋值过了的位置
	int i = 0;
	// 运算符
	String signal = "+";
	// 运算结果
	String result = "";

	// store的作用类似于寄存器
	JButton store;

	char[] vt = new char[200]; // 创建一个向量类对象vt,有20个元素的空间,若空间使用完时,以10个元素空间单位递增。
	
	// 声明各个UI组件对象并初始化
	JFrame frame = new JFrame("Calculator");
	JTextField result_TextField = new JTextField(result, 20);
	JButton clear_Button = new JButton("Clear");
	JButton button0 = new JButton("0");
	JButton button1 = new JButton("1");
	JButton button2 = new JButton("2");
	JButton button3 = new JButton("3");
	JButton button4 = new JButton("4");
	JButton button5 = new JButton("5");
	JButton button6 = new JButton("6");
	JButton button7 = new JButton("7");
	JButton button8 = new JButton("8");
	JButton button9 = new JButton("9");
	JButton button_Dian = new JButton(".");
	JButton button_jia = new JButton("+");
	JButton button_jian = new JButton("-");
	JButton button_cheng = new JButton("*");
	JButton button_chu = new JButton("/");
	JButton button_dy = new JButton("=");

	// 计算机类的构造器
	public Calculator2() {

		// 设置文本框为右对齐，使输入和结果都靠右显示
		result_TextField.setHorizontalAlignment(JTextField.RIGHT);

		// 将UI组件添加进容器内

		JPanel pan = new JPanel();
		pan.setLayout(new GridLayout(4, 4, 5, 5)); // GridLayout(int rows,int cols,int hgap,int
													// vgap);建立一个表格的版面对象。rows代表有几行，cols代表有几列；hgap是组件之间的水平距离，vgap是组件之间的竖直距离。
		pan.add(button7);
		pan.add(button8);
		pan.add(button9);
		pan.add(button_chu);
		pan.add(button4);
		pan.add(button5);
		pan.add(button6);
		pan.add(button_cheng);
		pan.add(button1);
		pan.add(button2);
		pan.add(button3);
		pan.add(button_jian);
		pan.add(button0);
		pan.add(button_Dian);
		pan.add(button_dy);
		pan.add(button_jia);
		pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));// 创建一个框，框的头部为5像素，左为5像素，底部为5像素，右为5像素宽。

		JPanel pan2 = new JPanel();
		pan2.setLayout(new BorderLayout());
		pan2.add(result_TextField, BorderLayout.WEST);
		pan2.add(clear_Button, BorderLayout.EAST);

		// 设置主窗口出现在屏幕上的位置
		frame.setLocation(60, 300);

		// 设置窗体不能调大小
		frame.setResizable(false);
		frame.getContentPane().setLayout(new BorderLayout());
		frame.getContentPane().add(pan2, BorderLayout.NORTH);
		frame.getContentPane().add(pan, BorderLayout.CENTER);
		frame.pack();
		frame.setVisible(true);

		// 事件处理程序

		// 数字键
		class Listener implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				String ss = ((JButton) e.getSource()).getText();// 获取数字键的数字
				str = str + ss;
				result_TextField.setText(str);
				store = (JButton) e.getSource();
				i++;
				char[] num = store.getLabel().toCharArray();
				switch (num[0]) {
				case '0':
					vt[i] = '0';
					break;
				case '1':
					vt[i] = '1';
					break;
				case '2':
					vt[i] = '2';
					break;
				case '3':
					vt[i] = '3';
					break;
				case '4':
					vt[i] = '4';
					break;
				case '5':
					vt[i] = '5';
					break;
				case '6':
					vt[i] = '6';
					break;
				case '7':
					vt[i] = '7';
					break;
				case '8':
					vt[i] = '8';
					break;
				case '9':
					vt[i] = '9';
					break;
				default:
					break;
				}
			}
		}

		// 输入的运算符号的处理
		class Listener_signal implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				String ss2 = ((JButton) e.getSource()).getText();
				str = str + ss2;
				result_TextField.setText(str);
				store = (JButton) e.getSource();
				i++;
				char[] operate = store.getLabel().toCharArray();
				switch (operate[0]) {
				case '+':
					vt[i] = '+';
					break;
				case '-':
					vt[i] = '-';
					break;
				case '*':
					vt[i] = '*';
					break;
				case '/':
					vt[i] = '/';
					break;
				case '.':
					vt[i] = '.';
					break;
				default:
					break;
				}
			}
		}

		// 清除键的逻辑（Clear）
		class Listener_clear implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				// 复位所有
				str = " ";
				i = 1;
				signal = "+";
				result = "";
				result_TextField.setText(result);
				char[] vt = new char[200]; 
			}
		}

		// 等于键的逻辑
		class Listener_dy implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				String ss3 = ((JButton) e.getSource()).getText();
				str = str + ss3;
				result_TextField.setText(str);
				TurnRPN cal = new TurnRPN();
				String expression = cal.getExpression(vt);
				System.out.print("转换成后缀表达式: ");
				System.out.println(expression);
				char[] vt2 = expression.toCharArray();
				ArrStack as = cal.rpn(vt2);
				result_TextField.setText(str+as.listStack());
			}
		}

		// 注册各个监听器，即绑定事件响应逻辑到各个UI组件上

		// 监听等于键
		Listener_dy jt_dy = new Listener_dy();
		// 监听数字键
		Listener jt = new Listener();
		// 监听符号键
		Listener_signal jt_signal = new Listener_signal();
		// 监听清除键
		Listener_clear jt_c = new Listener_clear();

		button7.addActionListener(jt);
		button8.addActionListener(jt);
		button9.addActionListener(jt);
		button_chu.addActionListener(jt_signal);
		button4.addActionListener(jt);
		button5.addActionListener(jt);
		button6.addActionListener(jt);
		button_cheng.addActionListener(jt_signal);
		button1.addActionListener(jt);
		button2.addActionListener(jt);
		button3.addActionListener(jt);
		button_jian.addActionListener(jt_signal);
		button0.addActionListener(jt);
		button_Dian.addActionListener(jt_signal);
		button_dy.addActionListener(jt_dy);
		button_jia.addActionListener(jt_signal);
		clear_Button.addActionListener(jt_c);

		// 窗体关闭事件的响应程序
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
	}

	public static void main(String[] args) {
		Calculator2 cal = new Calculator2();
	}
}

package Computer2;
import java.util.Arrays;
import java.util.Scanner;

import javax.swing.JOptionPane;
 
//简易计算器的编写 
//中缀表达式转后缀表达式  ,得出结果用于逆波兰数输出
 
//例如 输入:(11+2.2)*3.1+(30*45)-((1.1+23)*3.3)/5.2
//转换成后缀表达式: 11 2.2 + 3.1 * 30 45 * + 1.1 23 + 3.3 * 5.2 / - 
//输出结果:1375.6257692307693
public class TurnRPN {
	
//	public static void main(String[] args) {
//		
//		char[] s = getChar();
//		String expression = getExpression(s);
//		System.out.print("转换成后缀表达式: ");
//		System.out.println(expression);
//		//将字符串转换成字符数组
//		char[] s2 = expression.toCharArray();
//		ArrStack as = rpn(s2);
//		System.out.print("输出结果:");
//		as.listStack();
//	}
 
//	// 将输入的字符串转换成字符数组
//	public static char[] getChar() {
//		Scanner sc = new Scanner(System.in);
//		// 将输入的字符串转换成一个字符数组
//		System.out.println("请输入中缀表达式(请不要输入空格): ");
//		char[] s = sc.nextLine().toCharArray();
//		return s;
//	}
 
	// 中缀表达式转后缀表达式
	public static String getExpression(char[] s) {
		ArrStack as = new ArrStack();
		// 创建字符串存储后缀表达式
		String arr = "";
		for (int i = 0; i < s.length; i++) {
			// 如果是数字或者.直接放入字符串中
			if (isNumber(s[i]) || s[i] == '.') {
				arr = arr + s[i];
				// 判断数字是否完全输入,如果全部输入完毕,则在后面加上空格
				if (i != s.length - 1) {
					if (!isNumber(s[i + 1]) && s[i + 1] != '.') {
						arr = arr + " ";
					}
				} else {
					// 如果字符的最后一位是数字,则直接加空格(与最后出栈的运算符字符区分)
					arr = arr + " ";
				}
				// 如果是运算符字符,则判断后入栈
			} else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') {
				// 如果是= -则判断栈顶元素是否为 * / 如果是,先将栈顶元素出栈后再入栈 否则,直接入栈
				if (s[i] == '+' || s[i] == '-') {
					if (!as.isEmpty()) { // 判断栈是否为空
						char r = as.getTop();
						while (r == '+' || r == '-' || r == '*' || r == '/') {
							r = as.stackPop();
							arr = arr + r + " ";
							// 如果栈为空,则直接跳出循环
							if (!as.isEmpty()) {
								r = as.getTop();
							} else {
								break;
							}
						}
					}
					as.stackPush(s[i]);
				} else {
					as.stackPush(s[i]);
				}
				// 如果字符是(直接入栈,如果)则栈顶元素依次出栈,直到出栈元素是(为止
			} else if (s[i] == '(') {
				as.stackPush(s[i]);
			} else if (s[i] == ')') {
				char r = as.stackPop();
				while (r != '(') {
					arr = arr + r + " ";
					r = as.stackPop();
				}
			}
		}
		// 将栈中剩余的元素依次存入字符串中
		while (!as.isEmpty()) {
			char r = as.stackPop();
			arr = arr + r + " ";
		}
		return arr;
	}
 
	// 逆波兰表达式求值
	public static ArrStack rpn(char[] s) {
		ArrStack as = new ArrStack();
		double num = 0;
		// 定义空字符串存入字符
		String arr = "";
		double a = 0;
		double b = 0;
		double result = 0;
		for (int i = 0; i < s.length; i++) {
			// 如果是数字或者.则推入栈中
			if (isNumber(s[i]) || s[i] == '.') {
				arr = arr + s[i];
			} else if (s[i] == ' ') {
				// 遇到空格,将数据取出转成double类型推入栈中
				if (arr == "") {
					continue;
				} else {
					num = Double.valueOf(arr);
					as.stackPush(num);
					// 字符串置空
					arr = "";
				}
 
			} else {
				// 遇到运算符字符,弹出栈顶前两个数进行运算后再压入栈中
				switch (s[i]) {
				case '+':
					a = as.stackPop();
					b = as.stackPop();
					result = b + a;
					as.stackPush(result);
					break;
				case '-':
					a = as.stackPop();
					b = as.stackPop();
					result = b - a;
					as.stackPush(result);
					break;
				case '*':
					a = as.stackPop();
					b = as.stackPop();
					result = b * a;
					as.stackPush(result);
					break;
				case '/':
					a = as.stackPop();
					b = as.stackPop();
					if (a == 0) {
						JOptionPane.showMessageDialog(null, "除数不能为0!");
						System.out.println("除数不能为0!");
						break;
					}
					result = b / a;
					as.stackPush(result);
					break;
 
				}
			}
		}
		return as;
 
	}
 
	// 判断字符是否为数字
	public static boolean isNumber(char c) {
		if (c >= 48 && c <= 57) {
			return true;
		}
		return false;
	}
 
	// 创建顺序栈
	public static class ArrStack {
		// 定义数组保存元素
		private Object[] elementData;
		// 定义栈的当前长度
		private int size;
		// 定义栈的当前容量
		private int capacity;
		// 定义栈顶
		public int top;
 
		// 初始化,默认建立一个容量为50的数组
		public ArrStack() {
			elementData = new Object[50];
			capacity = 50;
		}
 
		// 初始化,自定义容量数组
		public ArrStack(int n) {
			elementData = new Object[n];
			capacity = n;
		}
 
		// 入栈
		public <T> void stackPush(T data) {
			// 如果容量满了,则新建一个数组扩充容量
			if (size >= capacity) {
				int newLength = (capacity * 3 / 2) + 1;
				elementData = Arrays.copyOf(elementData, newLength);
				capacity = newLength;
			}
			elementData[top] = data;
			top++;
			size++;
		}
 
		// 出栈
		public <T> T stackPop() {
			if (size == 0) {
				System.out.println("当前为空栈");
				return null;
			} else {
				T data = (T) this.elementData[top - 1];
				top--;
				size--;
				return data;
			}
 
		}
 
		// 遍历栈
		public String listStack() {
			String resultString = "";
			if (size == 0) {
				resultString = "空栈";
			} else if (size == 1) {
				resultString = elementData[top - 1].toString();
				// System.out.println("栈的长度" + size);
			} else {
				for (int i = 0; i < size; i++) {
					resultString = resultString + elementData[i];
				}
				resultString = resultString + "栈的长度" + size;
			}
			return resultString;
		}
 
		// 返回当前容量
		public void capacity() {
			System.out.println("当前最大容量" + capacity);
 
		}
 
		// 返回当前栈顶的值
		public <T> T getTop() {
			T data = (T) elementData[top - 1];
			return data;
		}
 
		// 判空
		public boolean isEmpty() {
			return size == 0;
		}
	}
}

package Computer3;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class Calculator3 extends JFrame{
 
    //定义JTextField 显示的字符串
    String string = new String();
 
    public Calculator3(){
        // 创建一个 Container 容器并初始化。
        Container container=getContentPane();
        //设置容器布局：网格布局样式，5行1列，水平间距50，垂直间距10
        container.setLayout(new GridLayout(5,1,50,10));
        // 创建一个 JTextField 对象并初始化。 JTextField 是用于显示操作和计算结果的文本框。
        // 参数 26 表明可以显示 26 列的文本内容
        JTextField result_TextField = new JTextField(26);
        //把字符串赋值给文本框
        result_TextField.setText(string);
        //创建一个带文本的按钮-->清除键
        JButton clear_Button = new JButton("    clear     ");
        //给按钮添加事件监听器
        clear_Button.addActionListener(clearButtonListener(result_TextField));
        //数字键0到9
        JButton button0 = new JButton("0");
        button0.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button1 = new JButton("1");
        button1.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button2 = new JButton("2");
        button2.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button3 = new JButton("3");
        button3.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button4 = new JButton("4");
        button4.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button5 = new JButton("5");
        button5.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button6 = new JButton("6");
        button6.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button7 = new JButton("7");
        button7.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button8 = new JButton("8");
        button8.addActionListener(numbersAndOperatorsListener(result_TextField));
        JButton button9 = new JButton("9");
        button9.addActionListener(numbersAndOperatorsListener(result_TextField));
        //计算命令按钮 加减乘除以及小数点等
        //小数点
        JButton button_spot = new JButton(".");
        button_spot.addActionListener(numbersAndOperatorsListener(result_TextField));
        //加
        JButton button_add = new JButton("+");
        button_add.addActionListener(numbersAndOperatorsListener(result_TextField));
        //减
        JButton button_subtract = new JButton("-");
        button_subtract.addActionListener(numbersAndOperatorsListener(result_TextField));
        //乘
        JButton button_multiply = new JButton("*");
        button_multiply.addActionListener(numbersAndOperatorsListener(result_TextField));
        //除
        JButton button_divide = new JButton("/");
        button_divide.addActionListener(numbersAndOperatorsListener(result_TextField));
        //等于
        JButton button_equal = new JButton("=");
        button_equal.addActionListener(equalButtonListener(result_TextField));
        //创建JPanel面板组件并且采用 BorderLayout布局格式
        JPanel panel = new JPanel(new BorderLayout());
        //在面板中添加文本框组件-->靠左
        panel.add(result_TextField,BorderLayout.WEST);
        //在面板中添加文本框组件-->靠右
        panel.add(clear_Button, BorderLayout.EAST);
        JPanel pan1 = new JPanel(new GridLayout(1,4,5,5));
          pan1.add(button7);
          pan1.add(button8);
          pan1.add(button9);
          pan1.add(button_divide);
        JPanel pan2 = new JPanel(new GridLayout(1,4,5,5));
          pan2.add(button4);
          pan2.add(button5);
          pan2.add(button6);
          pan2.add(button_multiply);
        JPanel pan3 = new JPanel(new GridLayout(1,4,5,5));
          pan3.add(button1);
          pan3.add(button2);
          pan3.add(button3);
          pan3.add(button_subtract);
        JPanel pan4 = new JPanel(new GridLayout(1,4,5,5));
          pan4.add(button0);
          pan4.add(button_spot);
          pan4.add(button_equal);
          pan4.add(button_add);
        //在容器上添加面板控件
        container.add(panel);
        container.add(pan1);
        container.add(pan2);
        container.add(pan3);
        container.add(pan4);
        //将容器外部特性实例化
        setTitle(" Calculator ");
        //设窗体的大小和位置
        setBounds(50,300,400,250);
        //设定窗体的可视化
        setVisible(true);
        //设置窗体的关闭方式
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    //数字和运算符监听事件
    public ActionListener numbersAndOperatorsListener(JTextField result_TextField ){
       return new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e) {
                JButton jButton = (JButton) e.getSource();
                System.out.println("获取事件监听器："+jButton.getText());
                string += jButton.getText();
                result_TextField.setText(string);
            }
        };
    }
    
    //使用JDK自带的类可以实现执行字符串中的运算公式的功能
    static ScriptEngine javaScriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");
    
    //等于运算
    public ActionListener equalButtonListener(JTextField result_TextField){
 
        return  new ActionListener() {
            String str =null;
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("result_TextField -->"+ result_TextField.getText());
                str = result_TextField.getText();
                string = equal(str);
                result_TextField.setText(string);
            }
            public String equal(String str){
                String result ="";
                try {
                    System.out.println(javaScriptEngine.eval(str));
                    result = javaScriptEngine.eval(str).toString();
                } catch (Exception t) {
                }
                return result;
            }
        };
    }
    
    //清除文本框的内容
    public ActionListener clearButtonListener(JTextField result_TextField){
        return  new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                string = "";
                result_TextField.setText(string);
            }
        };
    }
 
    public static void main(String[] args) {
        Calculator3 cal3 = new Calculator3();
    }
 
}