20177101010101 白玛次仁《面向对象程序设计》第十八周学习总结

实验十八  总复习

实验时间 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)点击窗口关闭,程序退出。

 1 package AA;
 2
 3 import java.awt.Dimension;
 4 import java.awt.Toolkit;
 5 import java.awt.Window;
 6
 7 public class WinCenter {
 8     public static void center(Window win){
 9         Toolkit tkit = Toolkit.getDefaultToolkit();
10         Dimension sSize = tkit.getScreenSize();
11         Dimension wSize = win.getSize();
12         if(wSize.height > sSize.height){
13             wSize.height = sSize.height;
14         }
15         if(wSize.width > sSize.width){
16             wSize.width = sSize.width;
17         }
18         win.setLocation((sSize.width - wSize.width)/ 2, (sSize.height - wSize.height)/ 2);
19     }
20 }

WinCenter

  1 package AA;
  2
  3 import java.awt.Dimension;
  4 import java.awt.FlowLayout;
  5 import java.awt.GridLayout;
  6
  7 import javax.swing.BorderFactory;
  8 import javax.swing.ButtonGroup;
  9 import javax.swing.JButton;
 10 import javax.swing.JCheckBox;
 11 import javax.swing.JComboBox;
 12 import javax.swing.JFrame;
 13 import javax.swing.JLabel;
 14 import javax.swing.JPanel;
 15 import javax.swing.JRadioButton;
 16 import javax.swing.JTextField;
 17
 18 public class DemoJFrame extends JFrame {
 19     private JPanel jPanel1;
 20     private JPanel jPanel2;
 21     private JPanel jPanel3;
 22     private JPanel jPanel4;
 23     private JTextField fieldname;
 24     private JComboBox comboBox;
 25     private JTextField fieldadress;
 26     private ButtonGroup bg;
 27     private JRadioButton Male;
 28     private JRadioButton Female;
 29     private JCheckBox read;
 30     private JCheckBox sing;
 31     private JCheckBox dance;
 32
 33     public DemoJFrame() {
 34         // 设置窗口大小
 35         this.setSize(800, 400);
 36         // 设置可见性
 37         this.setVisible(true);
 38         // 设置标题
 39         this.setTitle("编程练习一");
 40         // 设置关闭操作
 41         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
 42         // 设置窗口居中
 43         WinCenter.center(this);
 44         // 创建四个面板对象
 45         jPanel1 = new JPanel();
 46         setJPanel1(jPanel1);
 47         jPanel2 = new JPanel();
 48         setJPanel2(jPanel2);
 49         jPanel3 = new JPanel();
 50         setJPanel3(jPanel3);
 51         jPanel4 = new JPanel();
 52         setJPanel4(jPanel4);
 53         // 设置容器的为流布局
 54         FlowLayout flowLayout = new FlowLayout();
 55         this.setLayout(flowLayout);
 56         // 将四个面板添加到容器中
 57         this.add(jPanel1);
 58         this.add(jPanel2);
 59         this.add(jPanel3);
 60         this.add(jPanel4);
 61
 62     }
 63
 64     /*
 65      * 设置面一
 66      */
 67     private void setJPanel1(JPanel jPanel) {
 68         // TODO 自动生成的方法存根
 69         jPanel.setPreferredSize(new Dimension(700, 45));
 70         // 给面板的布局设置为网格布局 一行4列
 71         jPanel.setLayout(new GridLayout(1, 4));
 72
 73         JLabel name = new JLabel("name:");
 74         name.setSize(100, 50);
 75         fieldname = new JTextField("");
 76         fieldname.setSize(80, 20);
 77
 78         JLabel study = new JLabel("qualification:");
 79         comboBox = new JComboBox();
 80         comboBox.addItem("初中");
 81         comboBox.addItem("高中");
 82         comboBox.addItem("本科");
 83         jPanel.add(name);
 84         jPanel.add(fieldname);
 85         jPanel.add(study);
 86         jPanel.add(comboBox);
 87
 88     }
 89
 90     /*
 91      * 设置面板二
 92      */
 93     private void setJPanel2(JPanel jPanel) {
 94         // TODO 自动生成的方法存根
 95         jPanel.setPreferredSize(new Dimension(700, 50));
 96         // 给面板的布局设置为网格布局 一行4列
 97         jPanel.setLayout(new GridLayout(1, 4));
 98
 99         JLabel name = new JLabel("address:");
100         fieldadress = new JTextField();
101         fieldadress.setPreferredSize(new Dimension(150, 50));
102
103         JLabel study = new JLabel("hobby:");
104         JPanel selectBox = new JPanel();
105         selectBox.setBorder(BorderFactory.createTitledBorder(""));
106         selectBox.setLayout(new GridLayout(3, 1));
107         read = new JCheckBox("reading");
108         sing = new JCheckBox("singing");
109         dance = new JCheckBox("danceing");
110         selectBox.add(read);
111         selectBox.add(sing);
112         selectBox.add(dance);
113         jPanel.add(name);
114         jPanel.add(fieldadress);
115         jPanel.add(study);
116         jPanel.add(selectBox);
117     }
118
119     /*
120      * 设置面板三
121      */
122     private void setJPanel3(JPanel jPanel) {
123         // TODO 自动生成的方法存根
124         jPanel.setPreferredSize(new Dimension(700, 150));
125         FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);
126         jPanel.setLayout(flowLayout);
127         JLabel sex = new JLabel("性别:");
128         JPanel selectBox = new JPanel();
129         selectBox.setBorder(BorderFactory.createTitledBorder(""));
130         selectBox.setLayout(new GridLayout(2, 1));
131         bg = new ButtonGroup();
132         Male = new JRadioButton("male");
133         Female = new JRadioButton("female");
134         bg.add(Male );
135         bg.add(Female);
136         selectBox.add(Male);
137         selectBox.add(Female);
138         jPanel.add(sex);
139         jPanel.add(selectBox);
140
141     }
142
143     /*
144      * 设置面板四
145      */
146     private void setJPanel4(JPanel jPanel) {
147         // TODO 自动生成的方法存根
148         jPanel.setPreferredSize(new Dimension(700, 150));
149         FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 50, 10);
150         jPanel.setLayout(flowLayout);
151         jPanel.setLayout(flowLayout);
152         JButton sublite = new JButton("提交");
153         JButton reset = new JButton("重置");
154         sublite.addActionListener((e) -> valiData());
155         reset.addActionListener((e) -> Reset());
156         jPanel.add(sublite);
157         jPanel.add(reset);
158     }
159
160     /*
161      * 提交数据
162      */
163     private void valiData() {
164         // TODO 自动生成的方法存根
165         // 拿到数据
166         String name = fieldname.getText().toString().trim();
167         String xueli = comboBox.getSelectedItem().toString().trim();
168         String address = fieldadress.getText().toString().trim();
169         System.out.println(name);
170         System.out.println(xueli);
171         String hobbystring="";
172         if (read.isSelected()) {
173             hobbystring+="reading   ";
174         }
175         if (sing.isSelected()) {
176             hobbystring+="singing   ";
177         }
178         if (dance.isSelected()) {
179             hobbystring+="dancing  ";
180         }
181         System.out.println(address);
182         if (Male.isSelected()) {
183             System.out.println("male");
184         }
185         if (Female.isSelected()) {
186             System.out.println("female");
187         }
188         System.out.println(hobbystring);
189     }
190
191     /*
192      * 重置
193      */
194     private void Reset() {
195         // TODO 自动生成的方法存根
196         fieldadress.setText(null);
197         fieldname.setText(null);
198         comboBox.setSelectedIndex(0);
199         read.setSelected(false);
200         sing.setSelected(false);
201         dance.setSelected(false);
202         bg.clearSelection();
203     }
204 }

结果图:

练习2:采用GUI界面设计以下程序:

编制一个程序,将身份证号.txt 中的信息读入到内存中;

按姓名字典序输出人员信息;

查询最大年龄的人员信息;

查询最小年龄人员信息;

输入你的年龄,查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地;

查询人员中是否有你的同乡。

输入身份证信息,查询所提供身份证号的人员信息,要求输入一个身份证数字时,查询界面就显示满足查询条件的查询结果,且随着输入的数字的增多,查询匹配的范围逐渐缩小。

package 框图;

//import javax.swing.JFrame;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Timer;
import javax.swing.*;

public class Main1 extends JFrame {
    private static ArrayList<Person> Personlist;

    Scanner scanner = new Scanner(System.in);
    File file = new File("D:\\身份证号.txt");

    private JPanel Panel;
    private JLabel JLabel1;
    private JButton Button, Button2, Button3;
    private JTextArea text, text1, text2, text3;
    boolean tru = true;

    public Main1() {

        Panel = new JPanel();
        Panel.setLayout(null);
        Button = new JButton("1:按姓名字典序输出人员信息");
        Button2 = new JButton("2:查询最大年龄与最小年龄人员信息");
        Button3 = new JButton("查询相近年龄");
        JLabel1 = new JLabel("输入身份证号或者地址查询");
        JLabel1.setBounds(900, 50, 400, 30);

        text = new JTextArea(30, 80);
        text.setBounds(50, 180, 700, 700);
        text1 = new JTextArea(1, 30);
        text1.setBounds(900, 80, 400, 30);
        text2 = new JTextArea(30, 80);
        text2.setBounds(900, 180, 700, 700);
        text3 = new JTextArea(30, 80);
        text3.setBounds(420, 100, 200, 40);

        Button.addActionListener(new Action());
        Button.setBounds(50, 50, 300, 40);
        Button2.addActionListener(new Action1());
        Button2.setBounds(50, 100, 300, 40);
        Button3.addActionListener(new Action2());
        Button3.setBounds(650, 100, 120, 40);
        Panel.add(JLabel1);
        Panel.add(Button);
        Panel.add(Button2);
        Panel.add(Button3);
        Panel.add(text);
        Panel.add(text2);
        Panel.add(text1);
        Panel.add(text3);
        add(Panel);

        Timer timer = new Timer();
        TimerTask timeTask = new TimerTask() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                text2.setText(null);
                String place = text1.getText().toString().trim();
                for (int i = 0; i < Personlist.size(); i++) {

                    String Str = (String) Personlist.get(i).getbirthplace();
                    if (Str.contains(place) && !place.equals("")) {
                        text2.append(Personlist.get(i).toString());
                    }
                }
                for (int i = 0; i < Personlist.size(); i++) {

                    String Str = (String) Personlist.get(i).getID();
                    if (Str.contains(place) && !place.equals("")) {
                        text2.append(Personlist.get(i).toString());
                    }
                }

            }

        };
        timer.schedule(timeTask, 0, 100);

        Personlist = new ArrayList<>();
        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 ID = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String place = linescanner.nextLine();
                Person Person = new Person();
                Person.setname(name);
                Person.setID(ID);
                Person.setsex(sex);
                int a = Integer.parseInt(age);
                Person.setage(a);
                Person.setbirthplace(place);
                Personlist.add(Person);

            }
        } catch (FileNotFoundException e) {
            System.out.println("查找不到信息");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("信息读取有误");
            e.printStackTrace();
        }

    }

    private class Action implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            text.setText(null);
            Collections.sort(Personlist);
            text.append(Personlist.toString());
        }

    }

    private class Action1 implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            text.setText(null);
            int max = 0, min = 100;
            int j, k1 = 0, k2 = 0;
            for (int i = 1; i < Personlist.size(); i++) {
                j = Personlist.get(i).getage();
                if (j > max) {
                    max = j;
                    k1 = i;
                }
                if (j < min) {
                    min = j;
                    k2 = i;
                }
            }
            text.append("年龄最大:   " + Personlist.get(k1) + "\n" + "年龄最小:  " + Personlist.get(k2));
        }

    }

    private class Action2 implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            text.setText(null);
            int a = Integer.parseInt(text3.getText().toString().trim());
            int d_value = a - Personlist.get(agenear(a)).getage();

            for (int i = 0; i < Personlist.size(); i++) {
                int p = Personlist.get(i).getage() - a;

                if (p == d_value || -p == d_value)
                    text.append(Personlist.get(i).toString());
            }
        }

    }

    public static int agenear(int age) {

        int j = 0, min = 53, d_value = 0, k = 0;
        for (int i = 0; i < Personlist.size(); i++) {
            d_value = Personlist.get(i).getage() - age;
            if (d_value < 0)
                d_value = -d_value;
            if (d_value < min) {
                min = d_value;
                k = i;
            }

        }
        return k;

    }

}

main1

package  框图;
import java.awt.*;
import javax.swing.*;

public class ButtonTest {
    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            JFrame frame = new Main1();
            frame.setTitle("身份证");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        });
    }
}

ButtonTest

package project3;

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Toolkit;

import javax.swing.JFrame;

public class  Out{

    public static void main(String args[]) {
        Toolkit t = Toolkit.getDefaultToolkit();
        Dimension s = t.getScreenSize();
        EventQueue.invokeLater(() -> {
            JFrame frame = new Main1();
            frame.setBounds(0, 0, (int) s.getWidth(), (int) s.getHeight());
            frame.setTitle("身份查询系统");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        });
    }

}

out

package 框图;

public class Person implements Comparable<Person> {
    private String name;
    private String ID;
    private int age;
    private String sex;
    private String birthplace;

    public String getname() {
        return name;
    }

    public void setname(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public int getage() {

        return age;
    }

    public void setage(int age) {
        this.age = age;
    }

    public String getsex() {
        return sex;
    }

    public void setsex(String sex) {
        this.sex = sex;
    }

    public String getbirthplace() {
        return birthplace;
    }

    public void setbirthplace(String birthplace) {
        this.birthplace = birthplace;
    }

    public int compareTo(Person o) {
        return this.name.compareTo(o.getname());

    }

    public String toString() {
        return name + "\t" + sex + "\t" + age + "\t" + ID + "\t" + birthplace + "\n";

    }

}

person

练习3:采用GUI界面设计以下程序

编写一个计算器类,可以完成加、减、乘、除的操作

利用计算机类,设计一个小学生100以内数的四则运算练习程序,由计算机随机产生10道加减乘除练习题,学生输入答案,由程序检查答案是否正确,每道题正确计10分,错误不计分,10道题测试结束后给出测试总分;

将程序中测试练习题及学生答题结果输出到文件,文件名为test.txt。

package 计算器;

public class Main {

    public static void main(String[] args) {
        MyExGUI lg = new MyExGUI();
        // new MyExGUI();

    }

}
package 计算器;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JFrame;

public class chart extends JFrame {
    // 绘制柱形统计图
    ArrayList<Integer> ran = new ArrayList<Integer>();

    public chart(ArrayList<Integer> scores) {
        super();
        getContentPane().setForeground(Color.CYAN);
        setForeground(Color.CYAN);
        setBackground(Color.CYAN);
        for (int i = 0; i < scores.size(); i++) {
            ran.add(scores.get(i));
            System.out.println(scores.get(i));
        }

        setTitle("绘制柱形图");
        setSize(600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    @Override
    public void paint(Graphics g) {
        int Width = getWidth();
        int Height = getHeight();
        int leftMargin = 20;// 柱形图左边界
        int topMargin = 50;// 柱形图上边界
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(Color.WHITE);// 绘制白色背景
        g2.fillRect(0, 0, Width, Height - 100);// 绘制矩形图
        g2.setColor(Color.black);
        for (int i = 0; i <= 10; i++) {
            // 绘制灰色横线和百分比
            g2.drawString((100 - 10 * i) + " ", 15, topMargin + 30 * i);
            g2.drawLine(10, topMargin + 30 * i, Width, topMargin + 30 * i);// 绘制灰色横线
        }
        g2.setColor(Color.RED);
        for (int i = 0; i <= ran.size(); i++) {
            // 绘制柱形图
            int step = (i + 1) * 40;// 设置每个柱形图的水平间隔为40
            // 绘制矩形
            g2.fillRoundRect(leftMargin + step * 2 - 5, (100 - ran.get(i)) * 3 + 50, 40, 300 - (100 - ran.get(i)) * 3,
                    40, 10);
            // 列出测试轮数
            g2.drawString("第" + (i + 1) + "轮", leftMargin + step * 2, 380);
        }
    }

}
package 计算器;

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("D:\\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;
        }

    }

}
package 计算器;

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;
    }

}

实验总结:本学期学Java这门课后学到了好多关于计算机语言的出事用法,自己真的学到的内容并不多,但是收获了很多以前没接触过的还有好多。

学期学习总结:学习内容

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,学完十四章之后还行吧!对于我来说的确很难!

感谢老师和学长的教导!

原文地址:https://www.cnblogs.com/baimaciren/p/10200007.html

时间: 2024-10-09 00:29:06

20177101010101 白玛次仁《面向对象程序设计》第十八周学习总结的相关文章

20182333 2019-2020-1 《数据结构与面向对象程序设计》第八周学习总结

20182333 2019-2020-1 <数据结构与面向对象程序设计>第八周学习总结 教材学习内容总结 查找 1.查找:是一个过程,即在某个项目组中寻找某一项指定目标元素,或者确定该指定目标并不存在. 2.静态方法:也称为类方法,可以通过类名来调用,无需实例化该类的对象. 在方法声明中,通过使用static修饰符就可以把他声明为静态的. 3.泛型方法:要创建一个泛型方法,只需要在方法头的返回类型前插入一个泛型声明即可,其格式是:修饰符 返回类型 方法名(形参列表) { 方法体 }.例如: p

20182306 2019-2020-1 《数据结构与面向对象程序设计》第八周学习总结

目录 20182306 2019-2020-1 <数据结构与面向对象程序设计>第八周学习总结 教材学习内容总结 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考试错题总结 结对及互评 评分标准 点评模板: 点评过的同学博客和代码 其他(感悟.思考等,可选) 学习进度条 参考资料 20182306 2019-2020-1 <数据结构与面向对象程序设计>第八周学习总结 教材学习内容总结 查找 线性查找即按顺序从前向后一个一个进行查找,但是为了提高代码运行效率,可

20182332 2019-2020-1 《数据结构与面向对象程序设计》第八周学习总结

20182332 2019-2020-1 <数据结构与面向对象程序设计>第八周学习总结 教材学习内容总结 查找: 顺序查找: 顺序查找就是按顺序从头到尾依次往下查找,找到数据,则提前结束查找,找不到便一直查找下去,直到数据最后一位.适用于线性表的顺序存储结构和链式存储结构. 缺点:查找效率低. 二分查找: 将数列按有序化(递增或递减)排列,查找过程中采用跳跃式方式查找,即先以有序数列的中点位置为比较对象,如果要找的元素值小于该中点元素,则将待查序列缩小为左半部分,否则为右半部分.通过一次比较,

杨玲 201771010133《面向对象程序设计(java)》第十八周学习总结

 <面向对象程序设计(java)>第十八周学习总结 第一部分:理论知识学习部分 第二部分:实验部分 实验名称:实验十八  总复习 1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编

20182332 2019-2020-1 《数据结构与面向对象程序设计》第1周学习总结

20182332 2019-2020-1 <数据结构与面向对象程序设计>第1周学习总结1 教材学习内容总结 1.配置linux 虚拟机.java环境. 2.理解面向对象程序设计,包括属性.方法.封装等概念. Java基本结构,环境变量配置,集成开发环境. JAVA文件编译过程: 1.源文件由编译器编译成字节码(ByteCode) 2.字节码由java虚拟机解释运行. git命令: git init 创建本地版本库: git clone 与远程仓库建立联系: git add .将当前目录下文件添

《数据结构与面向对象程序设计》第1周学习总结

学号 2019-2020-2314 <数据结构与面向对象程序设计>第1周学习总结 教材学习内容总结 1.计算机系统是由软硬件组成的 2.java程序的结构组成(注释.标识符和保留字等) 注:java是大小写敏感的,大写和小写是有区别的 3.程序开发所包含的内容(程序设计语言的等级.编辑器.编译程序.解释程序.开发环境和语法语义) 4.在开发软件的过程中遇到问题时的解决步骤:理解问题.设计方案.考虑方案的选择并优化方案.实现方案.测试方案并修改存在的任何问题. 教材学习中的问题和解决过程 问题1

20182329 2019-2020-1 《数据结构与面向对象程序设计》第1周学习总结

20182329 2019-2020-1 <数据结构与面向对象程序设计>第1周学习总结 教材学习内容总结 git代码托管代码 Java的基本编程 jdb代码调试 教材学习中的问题和解决过程 问题1:在课本自学过程中,有一题是Java中有什么是不可能被识别的,我做错了一道(12345)可以被识别. 问题1解决方案:后来询问学长数字不与命令相匹配时不是有效的标识符,且标识符不能以数字为开头. 问题2:在自己对于课本代码编译时,发现自己main处显示错误 问题2解决方案:一开始我以为是我main的方

《数据结构与面向对象程序设计》第01周学习总结

目录 学号20182323 2019-2020-1 <数据结构与面向对象程序设计>第01周学习总结 教材学习内容总结 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考试错题总结 结对及互评 点评模板: 点评过的同学博客和代码 其他(感悟.思考等,可选) 学习进度条 参考资料 目录 学号20182323 2019-2020-1 <数据结构与面向对象程序设计>第01周学习总结 教材学习内容总结 学习了java的历史与发展. 学习了一些软件工具,开发环境等. 掌握

《数据结构与面向对象程序设计》第2-3周学习总结

学号20182329 2019-2020-1 <数据结构与面向对象程序设计>第2-3周学习总结 教材学习内容总结 条件语句和循环语句的使用 输入语句和输出语局应用 基本数据类型的转换和应用 各种类的使用方法,以及格式化输出的方法. 基本的类的编写 教材学习中的问题和解决过程 问题1:scanner输入时用short nextShort()输入时出现异常. 问题1解决方案:输入时应与前一项自己指定的数据类型一样才可以. 问题2:在应用impoet时使用import Java.util.*时并不会

20182320 2019-2020-1 《数据结构与面向对象程序设计》第4周学习总结

20182320 2019-2020-1 <数据结构与面向对象程序设计>第4周学习总结 1.教材学习内容总结 本周学习内容分为以下几个部分: 4.8.1 迭代器和for循环 5.1 再谈类和对象 5.2 类的剖析 5.3 封装 5.4 方法的剖析 5.5 静态类成员 5.6 类关系 5.7 方法设计 5.8 方法重载 5.9 测试 5.10 调试 4.8.1 迭代器和for循环 什么是迭代器? 迭代器是一个对象,我们可以使用它的方法来处理某集合中的元素,一次处理一个. 每个迭代器对象都有一个方