王颖奇 201771010129《面向对象程序设计Java》第十八周实验总结
实验十八 总复习
实验时间 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） 用户信息输入界面如下图所示:
（1）用户点击提交按钮时，用户输入信息显示控制台界面；
（2）用户点击重置按钮后，清空用户已输入信息；
（3）点击窗口关闭，程序退出。
代码：
package demo; import java.awt.*;
import javax.swing.*; public class Test {
public static void main(String[] args) {
EventQueue.invokeLater(() -> {
Frame frame = new Frame();
frame.setTitle("Student Detail");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
frame.setResizable(false);
});
}
}
package demo; import java.awt.*;
import javax.swing.*;
import java.awt.event.*; public class Frame extends JFrame {
private JPanel panel;
private JPanel panel1;
private JPanel panel2;
private JPanel buttonPanel;
private JComboBox<String> faceCombo;
private JCheckBox Reading;
private JCheckBox Singing;
private JCheckBox Dancing;
private JPanel panelDanXuan;
private ButtonGroup option;
private JRadioButton optionA;
private JRadioButton optionB;
private static final int DEFAULT_WITH = 800;
private static final int DEFAULT_HEIGHT = 400; public Frame() {
//框架a
panel = new JPanel();
panel.setPreferredSize(new Dimension(200,160));
panel.setLayout(new GridLayout(2,4));
JLabel lab = new JLabel("Name:", JLabel.CENTER);
final JTextField jt = new JTextField();
JLabel lab1 = new JLabel("Qualification:", JLabel.CENTER);
faceCombo = new JComboBox<>();
faceCombo.addItem("Graduate");
faceCombo.addItem("Not graduated");
JLabel lab2 = new JLabel("Adress:", JLabel.CENTER);
final JTextArea jt1 = new JTextArea();
JLabel lab3 = new JLabel("Hobby:", JLabel.CENTER);
panel1 = new JPanel();
Reading = new JCheckBox("Reading");
Singing = new JCheckBox("Singing");
Dancing = new JCheckBox("Dancing ");
//框架b
panel2 = new JPanel();
panel2.setPreferredSize(new Dimension(200,160));
JLabel lab4 = new JLabel("Sex:", JLabel.CENTER);
panelDanXuan = new JPanel();
option = new ButtonGroup();
optionA = new JRadioButton("Male");
optionB = new JRadioButton("Female");
//框架c
buttonPanel = new JPanel();
buttonPanel.setPreferredSize(new Dimension(200,80));
JButton jButton1 = new JButton("Validate");
JButton jButton2 = new JButton("Reset"); panel.add(lab);
panel.add(jt);
panel.add(lab1);
panel.add(faceCombo);
panel.add(lab2);
panel.add(jt1);
panel.add(lab3); panel1.add(Reading);
panel1.add(Singing);
panel1.add(Dancing);
panel1.setBorder(BorderFactory.createTitledBorder(""));
panel1.setLayout(new BoxLayout(panel1, BoxLayout.Y_AXIS));
panel.add(panel1); panel2.add(lab4);
option.add(optionA);
option.add(optionB);
panelDanXuan.add(optionA);
panelDanXuan.add(optionB);
panelDanXuan.setBorder(BorderFactory.createTitledBorder(""));
panelDanXuan.setLayout(new BoxLayout(panelDanXuan, BoxLayout.Y_AXIS)); panel2.add(panelDanXuan);
buttonPanel.add(jButton1);
buttonPanel.add(jButton2);
add(panel, BorderLayout.NORTH);
add(panel2, BorderLayout.WEST);
add(buttonPanel, BorderLayout.SOUTH);
setSize(DEFAULT_WITH, DEFAULT_HEIGHT); jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String Name = jt.getText();
if (Name != null) {
System.out.println("Name:"+Name);
}
String m = faceCombo.getSelectedItem().toString();
System.out.println("Qualification:"+m);
String Adress = jt1.getText();
if (Adress != null) {
System.out.println("Adress:"+Adress);
}
System.out.println("Hobby:");
if(Reading.isSelected()) {
System.out.println(Reading.getText());
}
if(Singing.isSelected()) {
System.out.println(Singing.getText());
}
if(Dancing.isSelected()) {
System.out.println(Dancing.getText());
}
System.out.println("Sex:");
if(optionA.isSelected()) {
System.out.println(optionA.getText());
}
if(optionB.isSelected()) {
System.out.println(optionB.getText());
}
}
});
jButton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
jt.setText("");
jt1.setText("");
faceCombo.setSelectedItem("Graduate");
Reading.setSelected(false);
Singing.setSelected(false);
Dancing.setSelected(false);
option.clearSelection();
}
});
}
}
运行结果;
练习2：采用GUI界面设计以下程序：
编制一个程序，将身份证号.txt 中的信息读入到内存中；
按姓名字典序输出人员信息；
查询最大年龄的人员信息；
查询最小年龄人员信息；
输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
查询人员中是否有你的同乡。
输入身份证信息，查询所提供身份证号的人员信息，要求输入一个身份证数字时，查询界面就显示满足查询条件的查询结果，且随着输入的数字的增多，查询匹配的范围逐渐缩小。
package demo1; import java.awt.*;
import javax.swing.*; public class ButtonTest {
public static void main(String[] args) {
EventQueue.invokeLater(() -> {
JFrame frame = new Main();
frame.setTitle("身份证");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}
package demo1; import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*; public class Main extends JFrame {
private static ArrayList<Student> studentlist;
private static ArrayList<Student> list;
private JPanel panel;
private JPanel buttonPanel;
private static final int DEFAULT_WITH = 600;
private static final int DEFAULT_HEIGHT = 300; public Main() {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("C:\\Users\\ASUS\\Desktop\\身份证号.txt");
try {
FileInputStream fis = new FileInputStream(file);
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
String temp = null;
while ((temp = in.readLine()) != null) { Scanner linescanner = new Scanner(temp); linescanner.useDelimiter(" ");
String name = linescanner.next();
String number = linescanner.next();
String sex = linescanner.next();
String age = linescanner.next();
String province = linescanner.nextLine();
Student student = new Student();
student.setName(name);
student.setnumber(number);
student.setsex(sex);
int a = Integer.parseInt(age);
student.setage(a);
student.setprovince(province);
studentlist.add(student); }
} catch (FileNotFoundException e) {
System.out.println("学生信息文件找不到");
e.printStackTrace();
} catch (IOException e) {
System.out.println("学生信息文件读取错误");
e.printStackTrace();
}
panel = new JPanel();
panel.setLayout(new BorderLayout());
JTextArea jt = new JTextArea();
panel.add(jt);
add(panel, BorderLayout.NORTH); buttonPanel = new JPanel();
buttonPanel.setLayout(new GridLayout(1, 7));
JButton jButton = new JButton("字典排序");
JButton jButton1 = new JButton("年龄最大和年龄最小");
JLabel lab = new JLabel("猜猜你的老乡");
JTextField jt1 = new JTextField();
JLabel lab1 = new JLabel("找找同龄人（年龄相近）：");
JTextField jt2 = new JTextField();
JLabel lab2 = new JLabel("输入你的身份证号码：");
JTextField jt3 = new JTextField();
JButton jButton2 = new JButton("退出"); jButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Collections.sort(studentlist);
jt.setText(studentlist.toString());
}
});
jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int max = 0, min = 100;
int j, k1 = 0, k2 = 0;
for (int i = 1; i < studentlist.size(); i++) {
j = studentlist.get(i).getage();
if (j > max) {
max = j;
k1 = i;
}
if (j < min) {
min = j;
k2 = i;
} }
jt.setText("年龄最大：" + studentlist.get(k1) + "年龄最小：" + studentlist.get(k2));
}
});
jButton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dispose();
System.exit(0);
}
});
jt1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String find = jt1.getText();
String text = "";
String place = find.substring(0, 3);
for (int i = 0; i < studentlist.size(); i++) {
if (studentlist.get(i).getprovince().substring(1, 4).equals(place)) {
text += "\n" + studentlist.get(i);
jt.setText("老乡：" + text);
}
}
}
});
jt2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String yourage = jt2.getText();
int a = Integer.parseInt(yourage);
int near = agenear(a);
int value = a - studentlist.get(near).getage();
jt.setText("年龄相近：" + studentlist.get(near));
}
}); jt3.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
list = new ArrayList<>();
Collections.sort(studentlist);
String key = jt3.getText(); for (int i = 1; i < studentlist.size(); i++) {
if (studentlist.get(i).getnumber().contains(key)) {
list.add(studentlist.get(i));
jt.setText("emmm！你可能是：\n" + list);
}
}
} });
buttonPanel.add(jButton);
buttonPanel.add(jButton1);
buttonPanel.add(lab);
buttonPanel.add(jt1);
buttonPanel.add(lab1);
buttonPanel.add(jt2);
buttonPanel.add(lab2);
buttonPanel.add(jt3);
buttonPanel.add(jButton2);
add(buttonPanel, BorderLayout.SOUTH);
setSize(DEFAULT_WITH, DEFAULT_HEIGHT);
} public static int agenear(int age) {
int min = 53, value = 0, k = 0;
for (int i = 0; i < studentlist.size(); i++) {
value = studentlist.get(i).getage() - age;
if (value < 0)
value = -value;
if (value < min) {
min = value;
k = i;
}
}
return k;
} }
package demo1;
public class Student implements Comparable<Student> {
private String name;
private String number ;
private String sex ;
private int age;
private String province;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getnumber() {
return number;
}
public void setnumber(String number) {
this.number = number;
}
public String getsex() {
return sex ;
}
public void setsex(String sex ) {
this.sex =sex ;
}
public int getage() {
return age;
}
public void setage(int age) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getprovince() {
return province;
}
public void setprovince(String province) {
this.province=province ;
}
public int compareTo(Student o) {
return this.name.compareTo(o.getName());
}
public String toString() {
return name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
}
}
练习3：采用GUI界面设计以下程序
编写一个计算器类，可以完成加、减、乘、除的操作
利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt。
package ui_test;
public class Main {
public static void main(String[] args) {
MyExGUI lg = new MyExGUI();
//new MyExGUI();
}
}
package ui_test; import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList; import javax.swing.*; public class MyExGUI extends JFrame {
ArrayList<String> user_zongti = new ArrayList<String>();
ArrayList<String> user_zonganswer = new ArrayList<String>();
ArrayList<String> user_answer = new ArrayList<String>();
ArrayList<String> true_answer = new ArrayList<String>();
ArrayList<String> jta_timu = new ArrayList<String>();
ArrayList<String> jta_zong = new ArrayList<String>();
ArrayList<Integer> user_fenshu = new ArrayList<Integer>();
JMenuBar jm; // 菜单条组件
JMenu menu;// 菜单
JMenuItem item1, item2;// 菜单项
JMenu build; // 二级菜单
JMenuItem file, project;
TextArea answer_all = new TextArea();
TextField jta = new TextField();
TextField jta_answer = new TextField();
JLabel num_answer = new JLabel();
JLabel answer;
JToolBar jtb;// 工具条
JButton jb1, jb2, jb3, jb4, jb5, jb6, jb7, jb_next;
int answer_count;
int answer_fenshu; public MyExGUI() {
// 创建菜单
jm = new JMenuBar(); menu = new JMenu("文件(F)");
menu.setMnemonic('f'); // 助记符 build = new JMenu("新建"); file = new JMenuItem("文件");
project = new JMenuItem("答题");
item1 = new JMenuItem("保存(S)");
item2 = new JMenuItem("退出"); answer = new JLabel("第 1 题"); // 添加菜单项至菜单上
build.add(file);
build.add(project); menu.add(build);
menu.add(item1);
menu.add(item2);
menu.addSeparator();
// 将菜单加入至菜单栏
jm.add(menu); JPanel contentPanel = new JPanel();
contentPanel.setLayout(null);
JLabel daan = new JLabel("答案");
JLabel dengyu = new JLabel("=");
num_answer = answer;
num_answer.setFont(new Font("宋体", Font.BOLD, 22));
jb_next = new JButton("下一题");
jta.setFont(new Font("宋体", Font.BOLD, 22));
jta_answer.setFont(new Font("宋体", Font.BOLD, 22));
jb_next.setFont(new Font("宋体", Font.BOLD, 22));
daan.setFont(new Font("宋体", Font.BOLD, 22));
dengyu.setFont(new Font("宋体", Font.BOLD, 22)); contentPanel.add(num_answer);
contentPanel.add(daan);
contentPanel.add(dengyu);
contentPanel.add(jta); contentPanel.add(jta_answer);
contentPanel.add(answer_all);
contentPanel.add(jb_next); num_answer.setBounds(90, 20, 130, 50);
daan.setBounds(250, 20, 90, 50);
jta.setBounds(50, 70, 150, 30);
dengyu.setBounds(205, 70, 20, 20);
jta_answer.setBounds(230, 70, 100, 30);
jb_next.setBounds(350, 70, 110, 30);
answer_all.setBounds(50, 120, 400, 300); this.setJMenuBar(jm); // 添加菜单栏，不能设定位置，会自动放在最上部
this.add(contentPanel); this.setTitle("在线答题系统");
this.setSize(600, 500);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
item1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
FileOutputStream outSTr = null;
BufferedOutputStream Buff = null;
boolean flag = true;
File file;
// String test ;
do {
// test = "test"+count; String inputValue = JOptionPane.showInputDialog("Please input file name");
file = new File(inputValue + "test.txt");
if (!file.exists()) {
// 创建文件
try { flag = file.createNewFile(); } catch (IOException e) {
e.printStackTrace(); }
flag = false;
} else { JOptionPane.showMessageDialog(null, "该文件名已存在，请重新输入", "ERROR", JOptionPane.ERROR_MESSAGE);
flag = true;
}
} while (flag);
// 写入文件
String u_answer;
try {
outSTr = new FileOutputStream(file);
Buff = new BufferedOutputStream(outSTr);
System.out.println("选择是后执行的代码" + user_zongti.size() + user_answer.size());
for (int i = 0; i < user_zongti.size(); i++) {
try {
Buff.write(user_zongti.get(i).getBytes());
Buff.write(" ".getBytes());
u_answer = user_answer.get(i);
if (u_answer.equals(""))
u_answer = "没有作答"; Buff.write(u_answer.getBytes());
Buff.write("\r\n".getBytes());
} catch (IOException e) {
e.printStackTrace();
i--;
}
}
Buff.flush();
Buff.close(); } catch (IOException e) {
e.printStackTrace();
}
try {
outSTr.close();
} catch (IOException e) {
e.printStackTrace();
}
user_zongti.clear();
user_answer.clear();
}
}); project.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
arithmetic art = new arithmetic();
true_answer = art.list_answer;
jta_timu = art.list_timu;
jta_zong = art.list;
answer_count = 1;
answer_all.setText("");
for (int i = 0; i < art.list_timu.size(); i++) {
user_zongti.add(jta_zong.get(i));
answer_all.append(jta_timu.get(i));
answer_all.append("\r\n");
}
num_answer.setText("第 " + answer_count + " 题");
jta.setText(jta_timu.get(answer_count - 1));
answer_count++; }
});
jb_next.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
String temp;
temp = jta_answer.getText(); if (jta.getText().equals("")) {
JOptionPane.showMessageDialog(null, "错误,请导入题库", "错误", JOptionPane.ERROR_MESSAGE);
return;
}
jta_answer.setText("");
if (answer_count <= 10) {
if (isInteger(temp)) { user_answer.add(temp);
System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
num_answer.setText("第 " + answer_count + " 题");
jta.setText(jta_timu.get(answer_count - 1));
answer_count++;
} else {
JOptionPane.showMessageDialog(null, "错误", "请输入数字", JOptionPane.ERROR_MESSAGE);
}
} else {
user_answer.add(temp);
System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
answer_fenshu = 0;
for (int i = 0; i < user_answer.size(); i++) {
if (user_answer.get(i).equals(true_answer.get(i)))
answer_fenshu += 5;
}
user_fenshu.add(answer_fenshu);
Object[] options = { "是", "取消" };
int res = JOptionPane.showOptionDialog(null, "是否查看成绩", "答题完毕", JOptionPane.DEFAULT_OPTION,
JOptionPane.YES_NO_OPTION, null, options, options[0]);
if (res == JOptionPane.YES_OPTION) {
chart ct = new chart(user_fenshu);
ct.setVisible(true); } else {
Object[] option = { "是", "取消" };
int res1 = JOptionPane.showOptionDialog(null, "是否退出程序", "终止框", JOptionPane.DEFAULT_OPTION,
JOptionPane.YES_NO_OPTION, null, option, option[0]); if (res1 == JOptionPane.YES_OPTION) {
dispose();
System.exit(0); } else { } } } }
}); item2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dispose();
System.exit(0);
}
}); } public static boolean isInteger(String str) {
for (int i = str.length(); --i >= 0;) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
} }
package ui_test; import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner; public class arithmetic {
ArrayList<String> list = new ArrayList<String>();
ArrayList<String> list_timu = new ArrayList<String>();
ArrayList<String> list_answer = new ArrayList<String>(); public arithmetic() {
FileOutputStream outSTr = null;
BufferedOutputStream Buff = null;
int number_n = 10, count; ArrayList<String> list_temp = new ArrayList<String>();
String[] operator = new String[] { "+", "-", "*", "/" }; Random rand = new Random();
File file1 = new File("test.txt");
if (file1.exists()) {
// 创建文件
try {
file1.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
} while (number_n > 0) {
int[] number_temp = new int[rand.nextInt(2) + 3];
String[] str_temp = new String[number_temp.length - 1];
for (int i = 0; i < number_temp.length; i++) {
if (i < number_temp.length - 1) {
number_temp[i] = rand.nextInt(100);
list_temp.add(String.valueOf(number_temp[i]));
str_temp[i] = operator[rand.nextInt(4)];
list_temp.add(str_temp[i]); } else {
number_temp[i] = rand.nextInt(100);
list_temp.add(String.valueOf(number_temp[i]));
}
} count = calculate_RPN(produce_RPN(list_temp));
if (count != -1) {
list_timu.add(transform_string(list_temp));
list_answer.add(String.valueOf(count));
list_temp.add(" = " + count);
list.add(transform_string(list_temp));
number_n--;
list_temp.clear();
} else
list_temp.clear();
System.out.println(number_n); }
try {
outSTr = new FileOutputStream(file1);
Buff = new BufferedOutputStream(outSTr);
for (int i = 0; i < list.size(); i++) {
try {
Buff.write(list.get(i).getBytes());
Buff.write("\r\n".getBytes());
} catch (IOException e) {
e.printStackTrace();
i--;
}
}
Buff.flush();
Buff.close(); } catch (IOException e) {
e.printStackTrace();
}
// Buff.close();
try {
outSTr.close();
} catch (IOException e) {
e.printStackTrace();
} for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
System.out.println();
}
System.out.print("计算完毕！"); } public static int calculate_RPN(ArrayList<String> list_temp) {
int i = 0, t;
double a = 0, b = 0;
String l_temp;
Stack sk = new Stack(10);
for (t = 0; t < list_temp.size(); t++) {
l_temp = list_temp.get(i++);
if (!isInteger(l_temp)) {
b = sk.mypop();
a = sk.mypop();
switch (l_temp) {
case "+":
sk.mypush(a + b);
break;
case "-":
if(!(a<b)) {
sk.mypush(a - b);
}
else
return -1;
break;
case "*":
sk.mypush(a * b);
break;
case "/":
if (b == 0||a<b)
return -1;
sk.mypush(a / b);
break;
}
System.out.println("st.mytop: " + sk.mypeek());
} else {
sk.mypush((double) Integer.parseInt(l_temp));
} }
if (!sk.myisempty()) {
a = sk.mypop();
b = a - (int) a;
System.out.println("a: " + a);
if (a > 0 && b == 0) {
return (int) a;
} else
return -1;
} else
return -1; } public static ArrayList<String> produce_RPN(ArrayList<String> list_temp) {
int t = 0, i = 0;
String tmp;
Tack mytack = new Tack(10);
ArrayList<String> lt_temp = new ArrayList<String>();
while (true) {
tmp = list_temp.get(i++);
if (isInteger(tmp)) {
lt_temp.add(tmp);
} else {
if (mytack.myisempty()) {
mytack.mypush(tmp);
} else {
if (isCPriority(tmp, mytack.mypeek()))
mytack.mypush(tmp);
else {
lt_temp.add(mytack.mypop());
mytack.mypush(tmp);
} }
}
if (i >= list_temp.size()) {
while (!mytack.myisempty())
lt_temp.add(mytack.mypop());
System.out.println(transform_string(list_temp));
list_temp = lt_temp;
System.out.println(list_temp);
return list_temp;
}
} } public static boolean isInteger(String str) {
for (int i = str.length(); --i >= 0;) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
} public static boolean isCPriority(String str, String s) {
if ((str + s).equals("*+") || (str + s).equals("*-") || (str + s).equals("/+") || (str + s).equals("/-"))
return true;
else
return false;
} public static String transform_string(ArrayList<String> list_temp) {
String s = "";
for (int i = 0; i < list_temp.size(); i++) {
s += list_temp.get(i);
}
return s; } static class Stack {
int mytop;
double stk[]; public Stack(int num) {
mytop = -1;
stk = new double[num];
} /* 出栈 */
double mypop() {
double peek = stk[mytop];
mytop--;
return peek;
} /* 入栈 */
void mypush(double x) {
mytop++;
stk[mytop] = x; } /* 判空 */
Boolean myisempty() {
if (mytop == -1)
return true;
else
return false;
} /* 取栈顶元素 */
double mypeek() {
double peek = stk[mytop];
return peek;
} /* 栈大小 */
int mysize() {
return mytop + 1;
}
} static class Tack {
int mytop;
String tk[]; public Tack(int num) {
mytop = -1;
tk = new String[num];
} /* 出栈 */
String mypop() {
String peek = tk[mytop];
mytop--;
return peek;
} /* 入栈 */
void mypush(String x) {
mytop++;
tk[mytop] = x; } /* 判空 */
Boolean myisempty() {
if (mytop == -1)
return true;
else
return false;
} /* 取栈顶元素 */
String mypeek() {
String peek = tk[mytop];
return peek;
} /* 栈大小 */
int mysize() {
return mytop + 1;
} } }
任务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章）
学习方法：
理论与实践（实验）学习相结合，课下自主学习：
1.理论课：老师讲授基础知识
2.实验课：老师和助教演示示例程序，并进行相应的更改和创新
3.课下自主学习：
（1）结合书籍内容和相关的示例程序，并自主查阅资料，完成编程练习。
（2）编程练习完成后，助教进行网络在线示范与讲解；老师根据出现的问题，在课堂上进行讲解。
学习心得：
通过本学期的学习，我掌握到了很多与java相关的基础知识，并能够运用它们来解决一些实际问题，但仍然有许多不理解的地方，需要我在以后的学习生活中来不断地探索与掌握；另外，本学期所学的java基础知识，如果要完成一些大的项目，是远远不够的。因此，我需要不断地练习以及补充相关的扩展知识，才能把自己的知识水平上升到能够熟练解决问题，并完美实现要求的境界。
最后，我十分感谢老师的谆谆教导和学长的耐心讲解，让我收获到了很多有用的知识和道理。
建议和意见：
示例程序和编程练习的数量有些大
王颖奇 201771010129《面向对象程序设计Java》第十八周实验总结的更多相关文章
- 201771010123汪慧和《面向对象程序设计JAVA》第八周实验总结
一.理论部分 1.接口 用interface声明,是抽象方法和常量值定义的集 合.从本质上讲,接口是一种特殊的抽象类. 在Java程序设计语言中,接口不是类,而是对类 的一组需求描述,由常量和一组抽象 ...
- 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结
<面向对象程序设计Java>第八周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...
- 201771010118马昕璐《面向对象程序设计java》第八周学习总结
第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...
- 201771010134杨其菊《面向对象程序设计java》第八周学习总结
第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类: Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...
- 201771010123汪慧和《面向对象程序设计JAVA》第七周实验总结
一.理论部分 1.继承 如果两个类存在继承关系,则子类会自动继承父类的方法和变量,在子类中可以调用父类的方法和变量,如果想要在子类里面做一系列事情,应该放在父类无参构造器里面,在java中,只允许单继 ...
- 201777010217-金云馨《面向对象程序设计Java》第八周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201771010123汪慧和《面向对象程序设计Java》第十三周实验总结
一.理论部分 1.GUI为用户提供交互式的图形化操作界面. (1)提供了程序的外观和感觉.(2)程序利用图形用户界面接受用户的输入,向用户输出程序运行的结果. 2.Java有专门的类库生成各种标准图 ...
- 201771010123汪慧和《面向对象程序设计Java》第十一周实验总结
一.理论部分 1.栈 (1)栈是一种特殊的线性表,是一种后进先出的结构.(2)栈是限定仅在表尾进行插入和删除运算的线性表,表尾称为栈顶,表头称为栈底.(3)栈的物理存储可以用顺序存储结构,也可以用链式 ...
- 马凯军201771010116《面向对象程序设计Java》第八周学习总结
一,理论知识学习部分 6.1.1 接口概念 两种含义:一,Java接口,Java语言中存在的结构,有特定的语法和结构:二,一个类所具有的方法的特征集合,是一种逻辑上的抽象.前者叫做“Java接口”,后 ...
- 周强201771010141《面向对象程序设计Java》第八周学习总结
一.理论知识学习部分 Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个接口. 接口体中包含常量定义和方法定义,接口中只进行方法的声明,不提供方法的实现. 类似建立类的继承关系 ...
随机推荐
- sql server临时删除/禁用非聚集索引并重新创建加回/启用的简便编程方法研究对比
前言: 由于新型冠状病毒影响,博主(zhang502219048)在2020年1月份从广东广州工作地回到广东揭阳产业转移工业园磐东街道(镇里有阳美亚洲玉都.五金之乡,素以“金玉”闻名)老家后,还没过去 ...
- 基于linux或windows的c/s的循环服务器求一元二次方程的根
在linux和windows上实现 c/s模式 socket循环服务器求解一元二次方程的根 ax^2+bx+c=0 根据上式,客户端发送a,b,c给服务器,返回求解的根 暂未考虑非法数据等问题 lin ...
- 【Java】关键字 和 保留字
Java的关键字[Keyword]和 保留字[Reserved word] 官方描述: https://docs.oracle.com/javase/tutorial/java/nutsandbolt ...
- 【LeetCode】23.合并K个排序链表
题目描述 23.合并K个排序链表 合并k个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. 示例: 输入: [ 1->4->5, 1->3->4, 2->6 ] ...
- c++学习day01基础知识学习
一.代码示例解析: #include <iostream> int main() { using namespace std; cout << "come up an ...
- 千亿级平台技术架构：为了支撑高并发，我把身份证存到了JS里
@ 目录 一.用户信息安全规范 1.1 用户信息.敏感信息定义及判断依据 1.1.1 个人信息 1.1.2 个人敏感信息 1.2 用户信息存储的注意事项 二.框架技术实现 2.1 用户敏感信息自 ...
- Linux 提高操作效率之 tab 命令补全
最近在使用阿里云 ECS 时,发现 Centos 无法进行 tab 补全,特别影响操作效率,本文简单记录下 Linux 下的 tab 命令补全功能,希望对 Linux 初学者有所帮助. 安装 Linu ...
- 数据类型、运算符、Scanner的使用
一.常见的基本数据类型 数值型 byte(最小,2字节) short(4字节) int (默认 8字节) long(16字节) 浮点型 f ...
- pytorch 矩阵数据增加维度unsqueeze和降低维度squeeze
增加一个维度 out.unsqueeze(-1) 降低一个维度 out.squeeze(dim=1)
- 十分钟搞懂Elasticsearch数字搜索原理
更多精彩内容请看我的个人博客或者扫描二维码,关注微信公众号:佛西先森 前言 Elasticsearch诞生的本意是为了解决文本搜索太慢的问题,ES会默认将所有的输入内容当作字符串来理解,对于字段类型是 ...