王颖奇 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 += "
" + 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！你可能是：
" + 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+"	"+sex+"	"+age+"	"+number+"	"+province+"
";
    }    
}

 练习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("
".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("
");
                }
                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("
".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基础知识，如果要完成一些大的项目，是远远不够的。因此，我需要不断地练习以及补充相关的扩展知识，才能把自己的知识水平上升到能够熟练解决问题，并完美实现要求的境界。

最后，我十分感谢老师的谆谆教导和学长的耐心讲解，让我收获到了很多有用的知识和道理。

建议和意见：

示例程序和编程练习的数量有些大