实验十八 总复习
实验时间 2018-12-30
1、实验目的与要求
(1) 综合掌握java基本程序结构；
(2) 综合掌握java面向对象程序设计特点；
(3) 综合掌握java GUI 程序设计结构；
(4) 综合掌握java多线程编程模型；
(5) 综合编程练习。
2、实验内容和步骤
任务1：填写课程课后调查问卷，网址：https://www.wjx.cn/jq/33108969.aspx。
任务2：综合编程练习
练习1：设计一个用户信息采集程序，要求如下：
1 package project1;
2
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 import javax.swing.border.*;
7
8 public class test extends JFrame {
9 public test() {
10 JPanel panel1 = new JPanel();
11 panel1.setPreferredSize(new Dimension(700, 45));
12 panel1.setLayout(new GridLayout(1, 4));
13 JLabel label1 = new JLabel("Name:");
14 JTextField j1 = new JTextField("");
15 JLabel label2 = new JLabel("Qualification:");
16 JComboBox<Object> j2 = new JComboBox<>();
17 j2.addItem("Graduate");
18 j2.addItem("Not Graduate");
19 panel1.add(label1);
20 panel1.add(j1);
21 panel1.add(label2);
22 panel1.add(j2);
23
24 JPanel panel2 = new JPanel();
25 panel2.setPreferredSize(new Dimension(700, 50));
26 panel2.setLayout(new GridLayout(1, 4));
27 JLabel label3 = new JLabel("Address:");
28 JTextArea j3 = new JTextArea();
29 JLabel label4 = new JLabel("Hobby:");
30 JPanel p = new JPanel();
31 p.setLayout(new GridLayout(3, 1));
32 p.setBorder(BorderFactory.createLineBorder(null));
33 JCheckBox c1 = new JCheckBox("Reading");
34 JCheckBox c2 = new JCheckBox("Singing");
35 JCheckBox c3 = new JCheckBox("Dancing");
36 p.add(c1);
37 p.add(c2);
38 p.add(c3);
39 panel2.add(label3);
40 panel2.add(j3);
41 panel2.add(label4);
42 panel2.add(p);
43
44 JPanel panel3 = new JPanel();
45 panel3.setPreferredSize(new Dimension(700, 150));
46 FlowLayout flowLayout1 = new FlowLayout(FlowLayout.CENTER, 50, 10);
47 panel3.setLayout(flowLayout1);
48 JLabel label5 = new JLabel("Sex:");
49 JPanel p1 = new JPanel();
50 p1.setLayout(new GridLayout(2, 1));
51 p1.setBorder(BorderFactory.createLineBorder(null));
52 ButtonGroup bu = new ButtonGroup();
53 JRadioButton jr1 = new JRadioButton("Male");
54 JRadioButton jr2 = new JRadioButton("Female");
55 bu.add(jr1);
56 bu.add(jr2);
57 p1.add(jr1);
58 p1.add(jr2);
59 panel3.add(label5);
60 panel3.add(p1);
61 add(panel1);
62 add(panel2);
63 add(panel3);
64
65 JPanel panel4 = new JPanel();
66 panel4.setPreferredSize(new Dimension(700, 150));
67 JButton b1 = new JButton("Validate");
68 panel4.add(b1);
69 JButton b2 = new JButton("Reset");
70 panel4.add(b2);
71 add(panel4);
72
73 FlowLayout flowLayout = new FlowLayout();
74 this.setLayout(flowLayout);
75 this.setTitle("Students Detail");
76 this.setBounds(200, 200, 800, 400);
77 this.setVisible(true);
78 this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
79
80 b1.addActionListener(new ActionListener() {
81
82 @Override
83 public void actionPerformed(ActionEvent e) {
84 String xueli = j2.getSelectedItem().toString();
85 System.out.println("Name:" + j1.getText());
86 System.out.println("Qualification:" + xueli);
87 String hobbystring = "Hobby:";
88 if (c1.isSelected()) {
89 hobbystring += "Reading";
90 }
91 if (c2.isSelected()) {
92 hobbystring += "Singing";
93 }
94 if (c3.isSelected()) {
95 hobbystring += "Dancing";
96 }
97 System.out.println("Address:" + j3.getText());
98 if (jr1.isSelected()) {
99 System.out.println("Sex:Male");
100 }
101 if (jr2.isSelected()) {
102 System.out.println("Sex:Female");
103 }
104 System.out.println(hobbystring);
105 }
106 });
107 b2.addActionListener(new ActionListener() {
108
109 @Override
110 public void actionPerformed(ActionEvent e) {
111 j1.setText(null);
112 j3.setText(null);
113 j2.setSelectedIndex(0);
114 c1.setSelected(false);
115 c2.setSelected(false);
116 c3.setSelected(false);
117 bu.clearSelection();
118 }
119 });
120 }
121
122 public static void main(String args[]) {
123 new test();
124 }
125
126 }（1） 用户信息输入界面如下图所示:
（1）用户点击提交按钮时，用户输入信息显示控制台界面；
（2）用户点击重置按钮后，清空用户已输入信息；
（3）点击窗口关闭，程序退出。
练习2：采用GUI界面设计以下程序：
l 编制一个程序，将身份证号.txt 中的信息读入到内存中；
l 按姓名字典序输出人员信息；
l 查询最大年龄的人员信息；
l 查询最小年龄人员信息；
l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
l 查询人员中是否有你的同乡。
l 输入身份证信息，查询所提供身份证号的人员信息，要求输入一个身份证数字时，查询界面就显示满足查询条件的查询结果，且随着输入的数字的增多，查询匹配的范围逐渐缩小。
1 package demo1;
2
3 import java.awt.*;
4 import javax.swing.*;
5
6 public class ButtonTest {
7 public static void main(String[] args) {
8 EventQueue.invokeLater(() -> {
9 JFrame frame = new Main();
10 frame.setTitle("身份证");
11 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12 frame.setVisible(true);
13 });
14 }
15 }
1 package demo1;
2
3 import java.io.BufferedReader;
4 import java.io.File;
5 import java.io.FileInputStream;
6 import java.io.InputStreamReader;
7 import java.io.FileNotFoundException;
8 import java.io.IOException;
9 import java.util.ArrayList;
10 import java.util.Arrays;
11 import java.util.Collections;
12 import java.util.Scanner;
13 import java.awt.*;
14 import javax.swing.*;
15 import java.awt.event.*;
16
17 public class Main extends JFrame {
18 private static ArrayList<Student> studentlist;
19 private static ArrayList<Student> list;
20 private JPanel panel;
21 private JPanel buttonPanel;
22 private static final int DEFAULT_WITH = 600;
23 private static final int DEFAULT_HEIGHT = 300;
24
25 public Main() {
26 studentlist = new ArrayList<>();
27 Scanner scanner = new Scanner(System.in);
28 File file = new File("C:\\Users\\ASUS\\Desktop\\身份证号.txt");
29 try {
30 FileInputStream fis = new FileInputStream(file);
31 BufferedReader in = new BufferedReader(new InputStreamReader(fis));
32 String temp = null;
33 while ((temp = in.readLine()) != null) {
34
35 Scanner linescanner = new Scanner(temp);
36
37 linescanner.useDelimiter(" ");
38 String name = linescanner.next();
39 String number = linescanner.next();
40 String sex = linescanner.next();
41 String age = linescanner.next();
42 String province = linescanner.nextLine();
43 Student student = new Student();
44 student.setName(name);
45 student.setnumber(number);
46 student.setsex(sex);
47 int a = Integer.parseInt(age);
48 student.setage(a);
49 student.setprovince(province);
50 studentlist.add(student);
51
52 }
53 } catch (FileNotFoundException e) {
54 System.out.println("学生信息文件找不到");
55 e.printStackTrace();
56 } catch (IOException e) {
57 System.out.println("学生信息文件读取错误");
58 e.printStackTrace();
59 }
60 panel = new JPanel();
61 panel.setLayout(new BorderLayout());
62 JTextArea jt = new JTextArea();
63 panel.add(jt);
64 add(panel, BorderLayout.NORTH);
65 buttonPanel = new JPanel();
66 buttonPanel.setLayout(new GridLayout(1, 7));
67 JButton jButton = new JButton("字典排序");
68 JButton jButton1 = new JButton("年龄最大和年龄最小");
69 JLabel lab = new JLabel("猜猜你的老乡");
70 JTextField jt1 = new JTextField();
71 JLabel lab1 = new JLabel("找找同龄人（年龄相近）：");
72 JTextField jt2 = new JTextField();
73 JLabel lab2 = new JLabel("输入你的身份证号码：");
74 JTextField jt3 = new JTextField();
75 JButton jButton2 = new JButton("退出");
76 jButton.setBounds(110, 90, 60, 30);
77 jButton1.setBounds(110, 90, 60, 30);
78 jt1.setBounds(110, 90, 60, 30);
79 jt2.setBounds(110, 90, 60, 30);
80 jt3.setBounds(110, 90, 60, 30);
81 jButton2.setBounds(110, 90, 60, 30);
82 jButton.addActionListener(new ActionListener() {
83 public void actionPerformed(ActionEvent e) {
84 Collections.sort(studentlist);
85 jt.setText(studentlist.toString());
86 }
87 });
88 jButton1.addActionListener(new ActionListener() {
89 public void actionPerformed(ActionEvent e) {
90 int max = 0, min = 100;
91 int j, k1 = 0, k2 = 0;
92 for (int i = 1; i < studentlist.size(); i++) {
93 j = studentlist.get(i).getage();
94 if (j > max) {
95 max = j;
96 k1 = i;
97 }
98 if (j < min) {
99 min = j;
100 k2 = i;
101 }
102
103 }
104 jt.setText("年龄最大：" + studentlist.get(k1) + "年龄最小：" + studentlist.get(k2));
105 }
106 });
107 jButton2.addActionListener(new ActionListener() {
108 public void actionPerformed(ActionEvent e) {
109 dispose();
110 System.exit(0);
111 }
112 });
113 jt1.addActionListener(new ActionListener() {
114 public void actionPerformed(ActionEvent e) {
115 String find = jt1.getText();
116 String text="";
117 String place = find.substring(0, 3);
118 for (int i = 0; i < studentlist.size(); i++) {
119 if (studentlist.get(i).getprovince().substring(1, 4).equals(place)) {
120 text+="\n"+studentlist.get(i);
121 jt.setText("老乡：" + text);
122 }
123 }
124 }
125 });
126 jt2.addActionListener(new ActionListener() {
127 public void actionPerformed(ActionEvent e) {
128 String yourage = jt2.getText();
129 int a = Integer.parseInt(yourage);
130 int near = agenear(a);
131 int value = a - studentlist.get(near).getage();
132 jt.setText("年龄相近：" + studentlist.get(near));
133 }
134 });
135 jt3.addActionListener(new ActionListener() {
136 public void actionPerformed(ActionEvent e) {
137 list = new ArrayList<>();
138 Collections.sort(studentlist);
139 String key = jt3.getText();
140 for (int i = 1; i < studentlist.size(); i++) {
141 if (studentlist.get(i).getnumber().contains(key)) {
142 list.add(studentlist.get(i));
143 jt.setText("emmm！你可能是：\n" + list);
144 //System.out.println("可能的人：" + studentlist.get(i));
145 //jt.setText("可能的人：" + studentlist.get(i));
146 }
147 }
148 }
149 });
150 buttonPanel.add(jButton);
151 buttonPanel.add(jButton1);
152 buttonPanel.add(lab);
153 buttonPanel.add(jt1);
154 buttonPanel.add(lab1);
155 buttonPanel.add(jt2);
156 buttonPanel.add(lab2);
157 buttonPanel.add(jt3);
158 buttonPanel.add(jButton2);
159 add(buttonPanel, BorderLayout.SOUTH);
160 setSize(DEFAULT_WITH, DEFAULT_HEIGHT);
161 }
162
163 public static int agenear(int age) {
164 int min = 53, value = 0, k = 0;
165 for (int i = 0; i < studentlist.size(); i++) {
166 value = studentlist.get(i).getage() - age;
167 if (value < 0)
168 value = -value;
169 if (value < min) {
170 min = value;
171 k = i;
172 }
173 }
174 return k;
175 }
176
177 }
178
179
180 Main
1 package demo1;
2
3 public class Student implements Comparable<Student> {
4
5 private String name;
6 private String number ;
7 private String sex ;
8 private int age;
9 private String province;
10
11 public String getName() {
12 return name;
13 }
14 public void setName(String name) {
15 this.name = name;
16 }
17 public String getnumber() {
18 return number;
19 }
20 public void setnumber(String number) {
21 this.number = number;
22 }
23 public String getsex() {
24 return sex ;
25 }
26 public void setsex(String sex ) {
27 this.sex =sex ;
28 }
29 public int getage() {
30
31 return age;
32 }
33 public void setage(int age) {
34 // int a = Integer.parseInt(age);
35 this.age= age;
36 }
37
38 public String getprovince() {
39 return province;
40 }
41 public void setprovince(String province) {
42 this.province=province ;
43 }
44
45 public int compareTo(Student o) {
46 return this.name.compareTo(o.getName());
47 }
48
49 public String toString() {
50 return name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
51 }
52 }
53
54
55 Student
练习3：采用GUI界面设计以下程序
l 编写一个计算器类，可以完成加、减、乘、除的操作
l 利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
l 将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt。
1 package ui_test;
2
3 import java.awt.*;
4 import java.awt.event.ActionEvent;
5 import java.awt.event.ActionListener;
6 import java.io.BufferedOutputStream;
7 import java.io.File;
8 import java.io.FileOutputStream;
9 import java.io.IOException;
10 import java.util.ArrayList;
11
12 import javax.swing.*;
13
14 public class MyExGUI extends JFrame {
15 ArrayList<String> user_zongti = new ArrayList<String>();
16 ArrayList<String> user_zonganswer = new ArrayList<String>();
17 ArrayList<String> user_answer = new ArrayList<String>();
18 ArrayList<String> true_answer = new ArrayList<String>();
19 ArrayList<String> jta_timu = new ArrayList<String>();
20 ArrayList<String> jta_zong = new ArrayList<String>();
21 ArrayList<Integer> user_fenshu = new ArrayList<Integer>();
22 JMenuBar jm; // 菜单条组件
23 JMenu menu;// 菜单
24 JMenuItem item1, item2;// 菜单项
25 JMenu build; // 二级菜单
26 JMenuItem file, project;
27 TextArea answer_all = new TextArea();
28 TextField jta = new TextField();
29 TextField jta_answer = new TextField();
30 JLabel num_answer = new JLabel();
31 JLabel answer;
32 JToolBar jtb;// 工具条
33 JButton jb1, jb2, jb3, jb4, jb5, jb6, jb7, jb_next;
34 int answer_count;
35 int answer_fenshu;
36
37 public MyExGUI() {
38 // 创建菜单
39 jm = new JMenuBar();
40
41 menu = new JMenu("文件(F)");
42 menu.setMnemonic('f'); // 助记符
43
44 build = new JMenu("新建");
45
46 file = new JMenuItem("文件");
47 project = new JMenuItem("答题");
48 item1 = new JMenuItem("保存(S)");
49 item2 = new JMenuItem("退出");
50
51 answer = new JLabel("第 1 题");
52
53 // 添加菜单项至菜单上
54 build.add(file);
55 build.add(project);
56
57 menu.add(build);
58 menu.add(item1);
59 menu.add(item2);
60 menu.addSeparator();
61 // 将菜单加入至菜单栏
62 jm.add(menu);
63
64 JPanel contentPanel = new JPanel();
65 contentPanel.setLayout(null);
66 JLabel daan = new JLabel("答案");
67 JLabel dengyu = new JLabel("=");
68 num_answer = answer;
69 num_answer.setFont(new Font("宋体", Font.BOLD, 22));
70 jb_next = new JButton("下一题");
71 jta.setFont(new Font("宋体", Font.BOLD, 22));
72 jta_answer.setFont(new Font("宋体", Font.BOLD, 22));
73 jb_next.setFont(new Font("宋体", Font.BOLD, 22));
74 daan.setFont(new Font("宋体", Font.BOLD, 22));
75 dengyu.setFont(new Font("宋体", Font.BOLD, 22));
76
77 contentPanel.add(num_answer);
78 contentPanel.add(daan);
79 contentPanel.add(dengyu);
80 contentPanel.add(jta);
81
82 contentPanel.add(jta_answer);
83 contentPanel.add(answer_all);
84 contentPanel.add(jb_next);
85
86 num_answer.setBounds(90, 20, 130, 50);
87 daan.setBounds(250, 20, 90, 50);
88 jta.setBounds(50, 70, 150, 30);
89 dengyu.setBounds(205, 70, 20, 20);
90 jta_answer.setBounds(230, 70, 100, 30);
91 jb_next.setBounds(350, 70, 110, 30);
92 answer_all.setBounds(50, 120, 400, 300);
93
94 this.setJMenuBar(jm); // 添加菜单栏，不能设定位置，会自动放在最上部
95 this.add(contentPanel);
96
97 this.setTitle("在线答题系统");
98 this.setSize(600, 500);
99 this.setVisible(true);
100 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
101 item1.addActionListener(new ActionListener() {
102 public void actionPerformed(ActionEvent arg0) {
103 FileOutputStream outSTr = null;
104 BufferedOutputStream Buff = null;
105 boolean flag = true;
106 File file;
107 // String test ;
108 do {
109 // test = "test"+count;
110
111 String inputValue = JOptionPane.showInputDialog("Please input file name");
112 file = new File(inputValue + "test.txt");
113 if (!file.exists()) {
114 // 创建文件
115 try {
116
117 flag = file.createNewFile();
118
119 } catch (IOException e) {
120 e.printStackTrace();
121
122 }
123 flag = false;
124 } else {
125
126 JOptionPane.showMessageDialog(null, "该文件名已存在，请重新输入", "ERROR", JOptionPane.ERROR_MESSAGE);
127 flag = true;
128 }
129 } while (flag);
130 // 写入文件
131 String u_answer;
132 try {
133 outSTr = new FileOutputStream(file);
134 Buff = new BufferedOutputStream(outSTr);
135 System.out.println("选择是后执行的代码" + user_zongti.size() + user_answer.size());
136 for (int i = 0; i < user_zongti.size(); i++) {
137 try {
138 Buff.write(user_zongti.get(i).getBytes());
139 Buff.write(" ".getBytes());
140 u_answer = user_answer.get(i);
141 if (u_answer.equals(""))
142 u_answer = "没有作答";
143
144 Buff.write(u_answer.getBytes());
145 Buff.write("\r\n".getBytes());
146 } catch (IOException e) {
147 e.printStackTrace();
148 i--;
149 }
150 }
151 Buff.flush();
152 Buff.close();
153
154 } catch (IOException e) {
155 e.printStackTrace();
156 }
157 try {
158 outSTr.close();
159 } catch (IOException e) {
160 e.printStackTrace();
161 }
162 user_zongti.clear();
163 user_answer.clear();
164 }
165 });
166
167 project.addActionListener(new ActionListener() {
168 public void actionPerformed(ActionEvent arg0) {
169 arithmetic art = new arithmetic();
170 true_answer = art.list_answer;
171 jta_timu = art.list_timu;
172 jta_zong = art.list;
173 answer_count = 1;
174 answer_all.setText("");
175 for (int i = 0; i < art.list_timu.size(); i++) {
176 user_zongti.add(jta_zong.get(i));
177 answer_all.append(jta_timu.get(i));
178 answer_all.append("\r\n");
179 }
180 num_answer.setText("第 " + answer_count + " 题");
181 jta.setText(jta_timu.get(answer_count - 1));
182 answer_count++;
183
184 }
185 });
186 jb_next.addActionListener(new ActionListener() {
187 public void actionPerformed(ActionEvent arg0) {
188 String temp;
189 temp = jta_answer.getText();
190
191 if (jta.getText().equals("")) {
192 JOptionPane.showMessageDialog(null, "错误,请导入题库", "错误", JOptionPane.ERROR_MESSAGE);
193 return;
194 }
195 jta_answer.setText("");
196 if (answer_count <= 10) {
197 if (isInteger(temp)) {
198
199 user_answer.add(temp);
200 System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
201 num_answer.setText("第 " + answer_count + " 题");
202 jta.setText(jta_timu.get(answer_count - 1));
203 answer_count++;
204 } else {
205 JOptionPane.showMessageDialog(null, "错误", "请输入数字", JOptionPane.ERROR_MESSAGE);
206 }
207 } else {
208 user_answer.add(temp);
209 System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
210 answer_fenshu = 0;
211 for (int i = 0; i < user_answer.size(); i++) {
212 if (user_answer.get(i).equals(true_answer.get(i)))
213 answer_fenshu += 5;
214 }
215 user_fenshu.add(answer_fenshu);
216 Object[] options = { "是", "取消" };
217 int res = JOptionPane.showOptionDialog(null, "是否查看成绩", "答题完毕", JOptionPane.DEFAULT_OPTION,
218 JOptionPane.YES_NO_OPTION, null, options, options[0]);
219 if (res == JOptionPane.YES_OPTION) {
220 chart ct = new chart(user_fenshu);
221 ct.setVisible(true);
222
223 } else {
224 Object[] option = { "是", "取消" };
225 int res1 = JOptionPane.showOptionDialog(null, "是否退出程序", "终止框", JOptionPane.DEFAULT_OPTION,
226 JOptionPane.YES_NO_OPTION, null, option, option[0]);
227
228 if (res1 == JOptionPane.YES_OPTION) {
229 dispose();
230 System.exit(0);
231
232 } else {
233
234 }
235
236 }
237
238 }
239
240 }
241 });
242
243 item2.addActionListener(new ActionListener() {
244 public void actionPerformed(ActionEvent e) {
245 dispose();
246 System.exit(0);
247 }
248 });
249
250 }
251
252 public static boolean isInteger(String str) {
253 for (int i = str.length(); --i >= 0;) {
254 if (!Character.isDigit(str.charAt(i))) {
255 return false;
256 }
257 }
258 return true;
259 }
260 }
1 package ui_test;
2
3 public class Main {
4
5 public static void main(String[] args) {
6 MyExGUI lg = new MyExGUI();
7 //new MyExGUI();
8
9 }
10
11 }
1 package ui_test;
2
3 import java.io.BufferedOutputStream;
4 import java.io.File;
5 import java.io.FileOutputStream;
6 import java.io.IOException;
7 import java.util.ArrayList;
8 import java.util.Random;
9 import java.util.Scanner;
10
11 public class arithmetic {
12 ArrayList<String> list = new ArrayList<String>();
13 ArrayList<String> list_timu = new ArrayList<String>();
14 ArrayList<String> list_answer = new ArrayList<String>();
15
16 public arithmetic() {
17 FileOutputStream outSTr = null;
18 BufferedOutputStream Buff = null;
19 int number_n = 10, count;
20
21 ArrayList<String> list_temp = new ArrayList<String>();
22 String[] operator = new String[] { "+", "-", "*", "/" };
23
24 Random rand = new Random();
25 File file1 = new File("test.txt");
26 if (file1.exists()) {
27 // 创建文件
28 try {
29 file1.createNewFile();
30 } catch (IOException e) {
31 e.printStackTrace();
32 }
33 }
34
35 while (number_n > 0) {
36 int[] number_temp = new int[rand.nextInt(2) + 3];
37 String[] str_temp = new String[number_temp.length - 1];
38 for (int i = 0; i < number_temp.length; i++) {
39 if (i < number_temp.length - 1) {
40 number_temp[i] = rand.nextInt(100);
41 list_temp.add(String.valueOf(number_temp[i]));
42 str_temp[i] = operator[rand.nextInt(4)];
43 list_temp.add(str_temp[i]);
44
45 }
46
47 else {
48 number_temp[i] = rand.nextInt(100);
49 list_temp.add(String.valueOf(number_temp[i]));
50 }
51 }
52
53 count = calculate_RPN(produce_RPN(list_temp));
54 if (count != -1) {
55 list_timu.add(transform_string(list_temp));
56 list_answer.add(String.valueOf(count));
57 list_temp.add(" = " + count);
58 list.add(transform_string(list_temp));
59 number_n--;
60 list_temp.clear();
61 } else
62 list_temp.clear();
63 System.out.println(number_n);
64
65 }
66 try {
67 outSTr = new FileOutputStream(file1);
68 Buff = new BufferedOutputStream(outSTr);
69 for (int i = 0; i < list.size(); i++) {
70 try {
71 Buff.write(list.get(i).getBytes());
72 Buff.write("\r\n".getBytes());
73 } catch (IOException e) {
74 e.printStackTrace();
75 i--;
76 }
77 }
78 Buff.flush();
79 Buff.close();
80
81 } catch (IOException e) {
82 e.printStackTrace();
83 }
84 // Buff.close();
85 try {
86 outSTr.close();
87 } catch (IOException e) {
88 e.printStackTrace();
89 }
90
91 for (int i = 0; i < list.size(); i++) {
92 System.out.print(list.get(i));
93 System.out.println();
94 }
95 System.out.print("计算完毕！");
96
97 }
98
99 public static int calculate_RPN(ArrayList<String> list_temp) {
100 int i = 0, t;
101 double a = 0, b = 0;
102 String l_temp;
103 Stack sk = new Stack(10);
104 for (t = 0; t < list_temp.size(); t++) {
105 l_temp = list_temp.get(i++);
106 if (!isInteger(l_temp)) {
107 b = sk.mypop();
108 a = sk.mypop();
109 switch (l_temp) {
110 case "+":
111 sk.mypush(a + b);
112 break;
113 case "-":
114 if(!(a<b)) {
115 sk.mypush(a - b);
116 }
117 else
118 return -1;
119 break;
120 case "*":
121 sk.mypush(a * b);
122 break;
123 case "/":
124 if (b == 0||a<b)
125 return -1;
126 sk.mypush(a / b);
127 break;
128 }
129 System.out.println("st.mytop: " + sk.mypeek());
130 } else {
131 sk.mypush((double) Integer.parseInt(l_temp));
132 }
133
134 }
135 if (!sk.myisempty()) {
136 a = sk.mypop();
137 b = a - (int) a;
138 System.out.println("a: " + a);
139 if (a > 0 && b == 0) {
140 return (int) a;
141 } else
142 return -1;
143 } else
144 return -1;
145
146 }
147
148 public static ArrayList<String> produce_RPN(ArrayList<String> list_temp) {
149 int t = 0, i = 0;
150 String tmp;
151 Tack mytack = new Tack(10);
152 ArrayList<String> lt_temp = new ArrayList<String>();
153 while (true) {
154 tmp = list_temp.get(i++);
155 if (isInteger(tmp)) {
156 lt_temp.add(tmp);
157 } else {
158 if (mytack.myisempty()) {
159 mytack.mypush(tmp);
160 }
161
162 else {
163 if (isCPriority(tmp, mytack.mypeek()))
164 mytack.mypush(tmp);
165 else {
166 lt_temp.add(mytack.mypop());
167 mytack.mypush(tmp);
168 }
169
170 }
171 }
172 if (i >= list_temp.size()) {
173 while (!mytack.myisempty())
174 lt_temp.add(mytack.mypop());
175 System.out.println(transform_string(list_temp));
176 list_temp = lt_temp;
177 System.out.println(list_temp);
178 return list_temp;
179 }
180 }
181
182 }
183
184 public static boolean isInteger(String str) {
185 for (int i = str.length(); --i >= 0;) {
186 if (!Character.isDigit(str.charAt(i))) {
187 return false;
188 }
189 }
190 return true;
191 }
192
193 public static boolean isCPriority(String str, String s) {
194 if ((str + s).equals("*+") || (str + s).equals("*-") || (str + s).equals("/+") || (str + s).equals("/-"))
195 return true;
196 else
197 return false;
198 }
199
200 public static String transform_string(ArrayList<String> list_temp) {
201 String s = "";
202 for (int i = 0; i < list_temp.size(); i++) {
203 s += list_temp.get(i);
204 }
205 return s;
206
207 }
208
209 static class Stack {
210 int mytop;
211 double stk[];
212
213 public Stack(int num) {
214 mytop = -1;
215 stk = new double[num];
216 }
217
218 /* 出栈 */
219 double mypop() {
220 double peek = stk[mytop];
221 mytop--;
222 return peek;
223 }
224
225 /* 入栈 */
226 void mypush(double x) {
227 mytop++;
228 stk[mytop] = x;
229
230 }
231
232 /* 判空 */
233 Boolean myisempty() {
234 if (mytop == -1)
235 return true;
236 else
237 return false;
238 }
239
240 /* 取栈顶元素 */
241 double mypeek() {
242 double peek = stk[mytop];
243 return peek;
244 }
245
246 /* 栈大小 */
247 int mysize() {
248 return mytop + 1;
249 }
250 }
251
252 static class Tack {
253 int mytop;
254 String tk[];
255
256 public Tack(int num) {
257 mytop = -1;
258 tk = new String[num];
259 }
260
261 /* 出栈 */
262 String mypop() {
263 String peek = tk[mytop];
264 mytop--;
265 return peek;
266 }
267
268 /* 入栈 */
269 void mypush(String x) {
270 mytop++;
271 tk[mytop] = x;
272
273 }
274
275 /* 判空 */
276 Boolean myisempty() {
277 if (mytop == -1)
278 return true;
279 else
280 return false;
281 }
282
283 /* 取栈顶元素 */
284 String mypeek() {
285 String peek = tk[mytop];
286 return peek;
287 }
288
289 /* 栈大小 */
290 int mysize() {
291 return mytop + 1;
292 }
293
294 }
295
296 }
297
298
299 arithmetic
1 package ui_test;
2
3 import java.awt.Color;
4 import java.awt.Graphics;
5 import java.awt.Graphics2D;
6 import java.util.ArrayList;
7 import java.util.Random;
8
9 import javax.swing.JFrame;
10
11 public class chart extends JFrame{
12 //绘制柱形统计图
13 ArrayList<Integer> ran=new ArrayList<Integer>();
14 public chart(ArrayList<Integer> scores)
15 {
16 super();
17 getContentPane().setForeground(Color.CYAN);
18 setForeground(Color.CYAN);
19 setBackground(Color.CYAN);
20 for(int i=0;i<scores.size();i++)
21 {
22 ran.add(scores.get(i));
23 System.out.println(scores.get(i));
24 }
25
26 setTitle("绘制柱形图");
27 setSize(600, 400);
28 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
29 }
30 @Override
31 public void paint(Graphics g){
32 int Width = getWidth();
33 int Height = getHeight();
34 int leftMargin = 20;//柱形图左边界
35 int topMargin = 50;//柱形图上边界
36 Graphics2D g2 = (Graphics2D) g;
37 g2.setColor(Color.WHITE);//绘制白色背景
38 g2.fillRect(0, 0, Width, Height-100);//绘制矩形图
39 g2.setColor(Color.black);
40 for(int i=0;i<=10;i++)
41 {
42 //绘制灰色横线和百分比
43 g2.drawString((100-10*i)+" ", 15, topMargin+30*i);
44 g2.drawLine(10, topMargin+30*i, Width, topMargin+30*i);//绘制灰色横线
45 }
46 g2.setColor(Color.RED);
47 for(int i=0;i<=ran.size();i++)
48 {
49 //绘制柱形图
50 int step = (i+1)*40;//设置每个柱形图的水平间隔为40
51 //绘制矩形
52 g2.fillRoundRect(leftMargin+step*2-5,(100-ran.get(i))*3+50, 40, 300-(100-ran.get(i))*3, 40, 10);
53 //列出测试轮数
54 g2.drawString("第"+(i+1)+"轮", leftMargin+step*2, 380);
55 }
56 }
57
58
59 }
60
61
62 chart
任务3：本学期课程已结束，请汇总《面向对象程序设计课程学习进度条》的数据，统计个人专业能力提升的数据。并从学习内容、学习方法、学习心得几个方面进行课程学习总结，也希望你对课程的不足提出建议和意见。
实验总结：
总复习纲要
Java语言特点与开发环境配置（第1章、第2章）
Java基本程序结构（第3章）
Java面向对象程序结构（第4章、第5章、第6章）
类、类间关系、类图
Java JDK预定义类/接口及其API（String-第3章、
Arrays-第3章、Files-第3章62页、LocalDate-第4章、
Object-第5章、对象包装器-第5章、Comparator-第6章、
异常类-第7章、ArrayList-第5+8章、第第9章、第10-12章、
第14章）
— Java异常处理编程模型
— Java GUI编程模型
Java并发程序设计（第14章）
Java应用程序部署（第13章）
JAVA特点
简单的、面向对象的、分布式的、强壮的、安全的、
体系结构中立的、可移植的、解释型的、高性能的、
多线程的、动态的语言。
JDK的安装及配置
JDK平台提供的Java编译器（javac.exe）和
Java解释器（java.exe）位于Java安装目录的
bin文件夹中，为了能在任何目录中使用编译器
和解释器，应在系统特性中设置Path
JDK的安装及配置
JDK安装目录的jre文件夹中包含着Java应用程
序运行时所需要的Java类库，这些类库被包含在jre\lib目录下的压缩文件rt.jar中
一个Java程序的开发过程
源文件的命名规则
如果源文件中有多个类，那么只能有一个类是public类。如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是.java。 如果源文件没有public类，那么源文件的名字只要和某个类的名字相同，并且扩展名是.java就可以了。 标识符、关键字和数据类型
Java标识符的组成
熟悉Java关键字 Java数据类型 Java一维数组的定义、初始化和数组元素 的引用Java数据类型
运算符与表达式
算术运算符，关系运算符，逻辑运算符，位运算符，赋值运算符，其他运算符
Java流程控制语句
控制语句， if语句， switch语句， 循环语句， while， do…while， for，break和continue语句， break——跳出switch结构；终止并跳出循环体。， continue——结束本次循环。
类、对象、继承和接口
类声明
class People
{
…
}
类体内容由两部分构成：
类成员变量：用来刻画类属性；
类成员方法：用来刻画类内操作。
局部变量
– 在方法体中定义的变量和方法的参数被称为局部变量。 类成员变量和局部变量的区别 类成员变量在整个类内都有效，局部变量只在定义它的方法内有效。
如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏。
类成员方法
—方法的定义包括两部分：方法声明和方法体。
构造方法
—名字必须与类名完全相同，没有返回值类型；
—构造方法可以重载；
—每个类至少有一个构造方法，若程序员没有定义构造方法，系统会自动产生一个默认构造方法，这个默认构造方法无参数，方法体为空；
—程序员为类定义了构造方法，系统就不再提供默认构造方法；
— 用途：初始化类对象。
方法重载
—一个类中可以有多个具有相同的名字的方法。但这些方法或者是参数的个数不同，或者是参数的类型不同创建对象需两个步骤：对象声明和为对象分配内存
—对象声明格式为：
类名 对象名字;
如：People zhangPing;
—为声明对象分配内存格式如下：
对象名= new 构造方法名(参数表);
如： zhangPing=new People();
—对象创建常用格式为：
类名 对象名= new 构造方法名(参数表);;类、对象、继承和接口 通过使用运算符“.”，对象可以实现对所属类具有访问权限的成员变量访问和成员方法调用。 没有分配内存的对象称作空对象，空对象不能使用，即不能让空对象去调用方法。类、对象、继承和接口
Static关键字
– 用static修饰的成员变量称为类（静态）变量
– 用static修饰的方法称为类（静态）方法
实例变量和类变量的区别
– 如果类的成员变量有类变量，那么该类所有对象的类变量内存是相同的。
– 具有访问权限的类变量可以通过某个对象访问，也可
以通过类名访问。
– 具有访问权限的实例变量仅可以通过对象访问，不能使用类名访问。类、对象、继承和接口实例方法和类方法的区别
– 实例方法可以被类创建的任何对象调用执行。
– 类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用 。
说明：
- 类方法可以调用其它类方法
- 类方法只能访问static成员变量
- 类方法不能以任何形式引用this和super
- 实例方法既可以访问实例成员变量也可访问类成员变量
- 实例方法既可以调用实例方法也可以调用类方法
this关键字
- this表示类的当前对象。
- this可以出现在实例方法和构造方法中，但不可以出现在类方法中。
- this关键字出现在构造方法中时，代表使用该构造方法所创建的对象。
- this出现在类的实例方法中时，代表正在调用该方法的当前对象。
实现类继承的方式
在类的声明中，通过使用关键字extends来创建一个类的子类，格式如下:
class 子类名 extends 父类名
{
…
}
类、对象、继承和接口
继承的规定
- Java只支持单继承，不允许多继承
- Java允许有多层继承
方法的重写
- 方法重写是指：子类中定义一个方法，这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。
- 子类重写父类，被重写的方法不能比父类拥有更严格的访问权限方法重载与方法重写的区别
成员变量的隐藏
- 子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量 。
super关键字
- 子类中访问父类中被隐藏的成员变量
- super.成员变量
- 子类调用父类中的方法
调用父类中的特定构造方法
super()
调用父类中被重写的方法
super.方法()
类、对象、继承和接口
子类对象与父类对象之间的转换
- 子类对象向父类对象转换,自动转型 父类对象=子类对象
- 父类对象向子类对象转换,强制转型 子类对象=（子类）父类对象类、对象、继承和接口多态性有两种表现形式：
①方法的多态性（方法重载）
②对象的多态性
对象多态性是在继承应用上的一种扩展类、对象、继承和接口final关键字
- final关键子可修饰类、方法成员、成员变量和方法中的参数。
- final类不能被继承，即不能有子类
- 方法被修饰为final方法，则这个方法不能被重写。
- 一个成员变量被修饰为final的，就是常量，常量必须赋给初值，而且不能再发生变化。
- 方法的参数被修饰为final的，该参数的值不能被改变。
类、对象、继承和接口
抽象类
- 用关键字abstract修饰的类称为abstract类（抽象类）。
abstract class A
{
„
}
- abstract类不能被实例化；
- abstract类可以有abstract方法；
- 对于abstract方法，只允许声明，不允许实现，且要用
abstract关键字进行修饰；
- 抽象类的子类必须重写所有的抽象方法。
类、对象、继承和接口
Java语言不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。
成员变量的隐藏
- 子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量 。
super关键字
- 子类中访问父类中被隐藏的成员变量
- super.成员变量
- 子类调用父类中的方法
调用父类中的特定构造方法
super()
调用父类中被重写的方法
super.方法()
子类对象与父类对象之间的转换
- 子类对象向父类对象转换,自动转型 父类对象=子类对象
- 父类对象向子类对象转换,强制转型 子类对象=（子类）父类对象
多态性有两种表现形式：
①方法的多态性（方法重载）
②对象的多态性
对象多态性是在继承应用上的一种扩展
final关键字
- final关键子可修饰类、方法成员、成员变量和方法中的参数。
- final类不能被继承，即不能有子类
- 方法被修饰为final方法，则这个方法不能被重写。
- 一个成员变量被修饰为final的，就是常量，常量必须赋给初值，而且不能再发生变化。
- 方法的参数被修饰为final的，该参数的值不能被改变。类、对象、继承和接口
抽象类
- 用关键字abstract修饰的类称为abstract类（抽象类）。
abstract class A
{
„
}
- abstract类不能被实例化；
- abstract类可以有abstract方法；
- 对于abstract方法，只允许声明，不允许实现，且要用
abstract关键字进行修饰；
- 抽象类的子类必须重写所有的抽象方法。、对象、继承和接口
Java语言不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。
接口的声明与使用
- 关键字interface来定义一个接口。
- 接口的定义与类的定义相似，包括接口的声明和接口体。
- 接口体中包含常量定义和抽象方法定义两部分。
如： interface Printable {
int MAX=100;
float sum(float x ,float y);
}
接口使用规则
- 一个类可以实现多个接口；
- 如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体。
class 类名 implements 接口A，接口B
{
…
}
一个新的接口用extends关键字去继承一个已有的接口，实现接口的多继承
interface 接口A extends 接口1，接口2，接口3，接口4
{
…
}
接口与抽象类的区别
package语句
- 必须是源文件中的第一条语句。在package语句之前，除了空白和注释之外不能有任何语句。
- 如果不加package语句，则指定为缺省包或无名包。
- 包对应着文件系统的目录层次结构。
- 在package语句中，用“.”来指明包（目录）的层次。
类、对象、继承和接口
引入包中的类
import java.io.File;
引入整个包
import java.io.*;
java默认导入的包
java.lang.*
在同一包中的类可以互相引用，无需import语句。
类的访问权限修饰符
- public
当两个类不在同一个包中时，允许外部类访问
- default 不能让不同包的外部类访问，但可以在同一个包中不同类之间访问类的其它修饰符
- final
- abstract
方法的权限访问修饰符
- public
- protected
- default(不加访问说明符时)
- private 方法的其它修饰符
- static
- final
- abstract
- synchronized（多线程中介绍）
public protected default privat
内部类
- Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。
- 内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。
匿名内部类
- 匿名内部类没有类名，所以创建匿名内部类时同时创建匿名内部类的对象
- 创建匿名内部类的语法格式如下所示
Lambda表达式
- Java 8 引入的一个新的功能，主要用途是提供一个函数化的语法来简化编码。
- Lambda表达式本质上是一个匿名方法。
类、类间关系、类图
类和类之间关系： is a，has a, use a
- is a： 继承，实现关系
- has a： 组合，聚合，关联关系
- use a： 依赖关系
继承关系
实现关系
public class Animal{}
public class Dog extends Animal{}
public interface UserService{}
public class UserService implements UserService{}
组合关系
public class Heart{}
publid class Stomach{}
public class Person{
private Heart heart;
private Stomach stomach;
public Person(){
this.heart=new Heart();
this.stomach=new Stomach();
}
}
聚合关系
public class Engine{}
public class Gearbox{}
publicc lass Car{
private Engine engine;
private Gearbox gearbox;
public Car(Engine engine, Gearbox gearbox){
this.engine=engine;
this. gearbox=gearbox;
}
}
关联关系
public class Car{}
public class Person{
private Car car;
public void setCar(){
this.car=car;
}
}
依赖关系
public class Train{
public void move(){}
}
public class Person{
public void move(Train train){
train.move();
}
}
类图：在OO程序设计中，进行类关系分析与设计的工具
JDK预定义类及其API
JDK中预定义类API使用要求：
- 导入类所在的包；
- 掌握预定义类的名称及其用途；
- 掌握预定义类中定义的常用方法、方法参数要求、返回值类型
异常处理编程模型
捕获异常编程框架
try
{
//此处是可能出现异常的代码
}
catch(Exception e)
{
//此处是如果发生异常的处理代码
}
finally
{
//此处是肯定被执行的代码
}
抛出异常
- throws语句是在方法的声明中使用来抛出异常，用来指定方法可能抛出异常，但不想在当前方法中处理这个异常。
- throw语句是在方法体内使用抛出异常类的对象，程序在执行到throw语句时立即终止，它后面的语句都不执行。
- 要捕捉throw抛出的异常，则必须使用try-catch语句。
异常处理编程模型
创建自定义异常类(*)
定义 extends Exception的子类
异常处理
Java GUI编程模型
掌握java.awt和java.swing包中各种
GUI定义需
要的组件创建以及常用方法
Java中的事件处理机制
- 事件由用户操作某个组件对象产生，被操作组件称为事件源。
- 一个组件能响应哪些事件，响应事件后需执行的语句序列存放在什么位置，这些功能由事件监视器负责。
- 事件监视器是某个实现了监听器接口类的对象。
-创建GUI中事件源，开发程序时，程序员需要做以下2件事：
向事件源注册事件监视器
例如，文本框的事件监听器注册方法是：
addActionListener(监视器);
创建该监视器对象的类，声明实现相应的接口 在类中实现接口中要求的事件处理方法
Java GUI编程模型
Java中的每个事件类都有一个相应的监视器接口，接口中声明了一个或多个抽象的事件处理方法。如果一个类实现事件监视器接口，其对象就可以作为对应事件的监视器，具备监视和处理事件的能力。
Java GUI编程模型
GUI设计中编写事件处理程序代码
必须确定事件源与事件监视器事件源的选择通常比较容易，事件监视器必须是实现事件监视器接口的类对象
Soureobject.addXXXListener(监视器)，将某个对象作为自己的监视器创建监视器对象的类必须实现相应的事件接口
Class A implements XXXListener
当事件源发生事件时，监视器将调用接口中的相应方法对事件进行处理
来源：oschina
链接：https://my.oschina.net/u/4415618/blog/4154192