zoukankan      html  css  js  c++  java

  • 201771010126 王燕《面向对象程序设计（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 package project1;
  2 
  3 import java.awt.*;
  4 import java.awt.event.*;
  5 import javax.swing.*;
  6 import javax.swing.border.*;
  7 
  8 public class test extends JFrame {
  9     public test() {
 10         JPanel panel1 = new JPanel();
 11         panel1.setPreferredSize(new Dimension(700, 45));
 12         panel1.setLayout(new GridLayout(1, 4));
 13         JLabel label1 = new JLabel("Name:");
 14         JTextField j1 = new JTextField("");
 15         JLabel label2 = new JLabel("Qualification:");
 16         JComboBox<Object> j2 = new JComboBox<>();
 17         j2.addItem("Graduate");
 18         j2.addItem("Not Graduate");
 19         panel1.add(label1);
 20         panel1.add(j1);
 21         panel1.add(label2);
 22         panel1.add(j2);
 23 
 24         JPanel panel2 = new JPanel();
 25         panel2.setPreferredSize(new Dimension(700, 50));
 26         panel2.setLayout(new GridLayout(1, 4));
 27         JLabel label3 = new JLabel("Address:");
 28         JTextArea j3 = new JTextArea();
 29         JLabel label4 = new JLabel("Hobby:");
 30         JPanel p = new JPanel();
 31         p.setLayout(new GridLayout(3, 1));
 32         p.setBorder(BorderFactory.createLineBorder(null));
 33         JCheckBox c1 = new JCheckBox("Reading");
 34         JCheckBox c2 = new JCheckBox("Singing");
 35         JCheckBox c3 = new JCheckBox("Dancing");
 36         p.add(c1);
 37         p.add(c2);
 38         p.add(c3);
 39         panel2.add(label3);
 40         panel2.add(j3);
 41         panel2.add(label4);
 42         panel2.add(p);
 43 
 44         JPanel panel3 = new JPanel();
 45         panel3.setPreferredSize(new Dimension(700, 150));
 46         FlowLayout flowLayout1 = new FlowLayout(FlowLayout.CENTER, 50, 10);
 47         panel3.setLayout(flowLayout1);
 48         JLabel label5 = new JLabel("Sex:");
 49         JPanel p1 = new JPanel();
 50         p1.setLayout(new GridLayout(2, 1));
 51         p1.setBorder(BorderFactory.createLineBorder(null));
 52         ButtonGroup bu = new ButtonGroup();
 53         JRadioButton jr1 = new JRadioButton("Male");
 54         JRadioButton jr2 = new JRadioButton("Female");
 55         bu.add(jr1);
 56         bu.add(jr2);
 57         p1.add(jr1);
 58         p1.add(jr2);
 59         panel3.add(label5);
 60         panel3.add(p1);
 61         add(panel1);
 62         add(panel2);
 63         add(panel3);
 64 
 65         JPanel panel4 = new JPanel();
 66         panel4.setPreferredSize(new Dimension(700, 150));
 67         JButton b1 = new JButton("Validate");
 68         panel4.add(b1);
 69         JButton b2 = new JButton("Reset");
 70         panel4.add(b2);
 71         add(panel4);
 72 
 73         FlowLayout flowLayout = new FlowLayout();
 74         this.setLayout(flowLayout);
 75         this.setTitle("Students Detail");
 76         this.setBounds(200, 200, 800, 400);
 77         this.setVisible(true);
 78         this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
 79 
 80         b1.addActionListener(new ActionListener() {
 81 
 82             @Override
 83             public void actionPerformed(ActionEvent e) {
 84                 String xueli = j2.getSelectedItem().toString();
 85                 System.out.println("Name:" + j1.getText());
 86                 System.out.println("Qualification:" + xueli);
 87                 String hobbystring = "Hobby:";
 88                 if (c1.isSelected()) {
 89                     hobbystring += "Reading";
 90                 }
 91                 if (c2.isSelected()) {
 92                     hobbystring += "Singing";
 93                 }
 94                 if (c3.isSelected()) {
 95                     hobbystring += "Dancing";
 96                 }
 97                 System.out.println("Address:" + j3.getText());
 98                 if (jr1.isSelected()) {
 99                     System.out.println("Sex:Male");
100                 }
101                 if (jr2.isSelected()) {
102                     System.out.println("Sex:Female");
103                 }
104                 System.out.println(hobbystring);
105             }
106         });
107         b2.addActionListener(new ActionListener() {
108 
109             @Override
110             public void actionPerformed(ActionEvent e) {
111                 j1.setText(null);
112                 j3.setText(null);
113                 j2.setSelectedIndex(0);
114                 c1.setSelected(false);
115                 c2.setSelected(false);
116                 c3.setSelected(false);
117                 bu.clearSelection();
118             }
119         });
120     }
121 
122     public static void main(String args[]) {
123         new test();
124     }
125 
126 }
    View Code

     （1）  用户信息输入界面如下图所示:

     （1）用户点击提交按钮时，用户输入信息显示控制台界面；

    （2）用户点击重置按钮后，清空用户已输入信息；

     （3）点击窗口关闭，程序退出。

     

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

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

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

    l  查询最大年龄的人员信息；

    l  查询最小年龄人员信息；

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

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

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

     1 package demo1;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 public class ButtonTest {
 7     public static void main(String[] args) {
 8         EventQueue.invokeLater(() -> {
 9             JFrame frame = new Main();
10             frame.setTitle("身份证");
11             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12             frame.setVisible(true);
13         });
14     }
15 }
    View Code
      1 package demo1;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.File;
  5 import java.io.FileInputStream;
  6 import java.io.InputStreamReader;
  7 import java.io.FileNotFoundException;
  8 import java.io.IOException;
  9 import java.util.ArrayList;
 10 import java.util.Arrays;
 11 import java.util.Collections;
 12 import java.util.Scanner;
 13 import java.awt.*;
 14 import javax.swing.*;
 15 import java.awt.event.*;
 16 
 17 public class Main extends JFrame {
 18     private static ArrayList<Student> studentlist;
 19     private static ArrayList<Student> list;
 20     private JPanel panel;
 21     private JPanel buttonPanel;
 22     private static final int DEFAULT_WITH = 600;
 23     private static final int DEFAULT_HEIGHT = 300;
 24 
 25     public Main() {
 26         studentlist = new ArrayList<>();
 27         Scanner scanner = new Scanner(System.in);
 28         File file = new File("C:\Users\ASUS\Desktop\身份证号.txt");
 29         try {
 30             FileInputStream fis = new FileInputStream(file);
 31             BufferedReader in = new BufferedReader(new InputStreamReader(fis));
 32             String temp = null;
 33             while ((temp = in.readLine()) != null) {
 34 
 35                 Scanner linescanner = new Scanner(temp);
 36 
 37                 linescanner.useDelimiter(" ");
 38                 String name = linescanner.next();
 39                 String number = linescanner.next();
 40                 String sex = linescanner.next();
 41                 String age = linescanner.next();
 42                 String province = linescanner.nextLine();
 43                 Student student = new Student();
 44                 student.setName(name);
 45                 student.setnumber(number);
 46                 student.setsex(sex);
 47                 int a = Integer.parseInt(age);
 48                 student.setage(a);
 49                 student.setprovince(province);
 50                 studentlist.add(student);
 51 
 52             }
 53         } catch (FileNotFoundException e) {
 54             System.out.println("学生信息文件找不到");
 55             e.printStackTrace();
 56         } catch (IOException e) {
 57             System.out.println("学生信息文件读取错误");
 58             e.printStackTrace();
 59         }
 60         panel = new JPanel();
 61         panel.setLayout(new BorderLayout());
 62         JTextArea jt = new JTextArea();
 63         panel.add(jt);
 64         add(panel, BorderLayout.NORTH);
 65         buttonPanel = new JPanel();
 66         buttonPanel.setLayout(new GridLayout(1, 7));
 67         JButton jButton = new JButton("字典排序");
 68         JButton jButton1 = new JButton("年龄最大和年龄最小");
 69         JLabel lab = new JLabel("猜猜你的老乡");
 70         JTextField jt1 = new JTextField();
 71         JLabel lab1 = new JLabel("找找同龄人（年龄相近）：");
 72         JTextField jt2 = new JTextField();
 73         JLabel lab2 = new JLabel("输入你的身份证号码：");
 74         JTextField jt3 = new JTextField();
 75         JButton jButton2 = new JButton("退出");
 76         jButton.setBounds(110, 90, 60, 30);
 77         jButton1.setBounds(110, 90, 60, 30);
 78         jt1.setBounds(110, 90, 60, 30);
 79         jt2.setBounds(110, 90, 60, 30);
 80         jt3.setBounds(110, 90, 60, 30);
 81         jButton2.setBounds(110, 90, 60, 30);
 82         jButton.addActionListener(new ActionListener() {
 83             public void actionPerformed(ActionEvent e) {
 84                 Collections.sort(studentlist);
 85                 jt.setText(studentlist.toString());
 86             }
 87         });
 88         jButton1.addActionListener(new ActionListener() {
 89             public void actionPerformed(ActionEvent e) {
 90                 int max = 0, min = 100;
 91                 int j, k1 = 0, k2 = 0;
 92                 for (int i = 1; i < studentlist.size(); i++) {
 93                     j = studentlist.get(i).getage();
 94                     if (j > max) {
 95                         max = j;
 96                         k1 = i;
 97                     }
 98                     if (j < min) {
 99                         min = j;
100                         k2 = i;
101                     }
102 
103                 }
104                 jt.setText("年龄最大：" + studentlist.get(k1) + "年龄最小：" + studentlist.get(k2));
105             }
106         });
107         jButton2.addActionListener(new ActionListener() {
108             public void actionPerformed(ActionEvent e) {
109                 dispose();
110                 System.exit(0);
111             }
112         });
113         jt1.addActionListener(new ActionListener() {
114             public void actionPerformed(ActionEvent e) {
115                 String find = jt1.getText();
116                 String text="";
117                 String place = find.substring(0, 3);
118                 for (int i = 0; i < studentlist.size(); i++) {
119                     if (studentlist.get(i).getprovince().substring(1, 4).equals(place)) {
120                         text+="
"+studentlist.get(i);
121                         jt.setText("老乡：" + text);
122                     }
123                 }
124             }
125         });
126         jt2.addActionListener(new ActionListener() {
127             public void actionPerformed(ActionEvent e) {
128                 String yourage = jt2.getText();
129                 int a = Integer.parseInt(yourage);
130                 int near = agenear(a);
131                 int value = a - studentlist.get(near).getage();
132                 jt.setText("年龄相近：" + studentlist.get(near));
133             }
134         });
135         jt3.addActionListener(new ActionListener() {
136             public void actionPerformed(ActionEvent e) {
137                 list = new ArrayList<>();
138                 Collections.sort(studentlist);
139                 String key = jt3.getText();
140                 for (int i = 1; i < studentlist.size(); i++) {
141                     if (studentlist.get(i).getnumber().contains(key)) {                        
142                         list.add(studentlist.get(i));                        
143                         jt.setText("emmm！你可能是：
" + list);
144                         //System.out.println("可能的人：" + studentlist.get(i));
145                         //jt.setText("可能的人：" + studentlist.get(i));
146                     }                    
147                 }
148             }
149         });
150         buttonPanel.add(jButton);
151         buttonPanel.add(jButton1);
152         buttonPanel.add(lab);
153         buttonPanel.add(jt1);
154         buttonPanel.add(lab1);
155         buttonPanel.add(jt2);
156         buttonPanel.add(lab2);
157         buttonPanel.add(jt3);
158         buttonPanel.add(jButton2);
159         add(buttonPanel, BorderLayout.SOUTH);
160         setSize(DEFAULT_WITH, DEFAULT_HEIGHT);
161     }
162 
163     public static int agenear(int age) {
164         int min = 53, value = 0, k = 0;
165         for (int i = 0; i < studentlist.size(); i++) {
166             value = studentlist.get(i).getage() - age;
167             if (value < 0)
168                 value = -value;
169             if (value < min) {
170                 min = value;
171                 k = i;
172             }
173         }
174         return k;
175     }
176 
177 }
178 
179 
180 Main
    View Code
     1 package demo1;
 2 
 3 public class Student implements Comparable<Student> {
 4 
 5     private String name;
 6     private String number ;
 7     private String sex ;
 8     private int age;
 9     private String province;
10    
11     public String getName() {
12         return name;
13     }
14     public void setName(String name) {
15         this.name = name;
16     }
17     public String getnumber() {
18         return number;
19     }
20     public void setnumber(String number) {
21         this.number = number;
22     }
23     public String getsex() {
24         return sex ;
25     }
26     public void setsex(String sex ) {
27         this.sex =sex ;
28     }
29     public int getage() {
30 
31         return age;
32         }
33         public void setage(int age) {
34             // int a = Integer.parseInt(age);
35         this.age= age;
36         }
37 
38     public String getprovince() {
39         return province;
40     }
41     public void setprovince(String province) {
42         this.province=province ;
43     }
44 
45     public int compareTo(Student o) {
46        return this.name.compareTo(o.getName());
47     }
48 
49     public String toString() {
50         return  name+"	"+sex+"	"+age+"	"+number+"	"+province+"
";
51     }    
52 }
53 
54 
55 Student
    View Code

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

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

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

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

      1 package ui_test;
  2 
  3 import java.awt.*;
  4 import java.awt.event.ActionEvent;
  5 import java.awt.event.ActionListener;
  6 import java.io.BufferedOutputStream;
  7 import java.io.File;
  8 import java.io.FileOutputStream;
  9 import java.io.IOException;
 10 import java.util.ArrayList;
 11 
 12 import javax.swing.*;
 13 
 14 public class MyExGUI extends JFrame {
 15     ArrayList<String> user_zongti = new ArrayList<String>();
 16     ArrayList<String> user_zonganswer = new ArrayList<String>();
 17     ArrayList<String> user_answer = new ArrayList<String>();
 18     ArrayList<String> true_answer = new ArrayList<String>();
 19     ArrayList<String> jta_timu = new ArrayList<String>();
 20     ArrayList<String> jta_zong = new ArrayList<String>();
 21     ArrayList<Integer> user_fenshu = new ArrayList<Integer>();
 22     JMenuBar jm; // 菜单条组件
 23     JMenu menu;// 菜单
 24     JMenuItem item1, item2;// 菜单项
 25     JMenu build; // 二级菜单
 26     JMenuItem file, project;
 27     TextArea answer_all = new TextArea();
 28     TextField jta = new TextField();
 29     TextField jta_answer = new TextField();
 30     JLabel num_answer = new JLabel();
 31     JLabel answer;
 32     JToolBar jtb;// 工具条
 33     JButton jb1, jb2, jb3, jb4, jb5, jb6, jb7, jb_next;
 34     int answer_count;
 35     int answer_fenshu;
 36 
 37     public MyExGUI() {
 38         // 创建菜单
 39         jm = new JMenuBar();
 40 
 41         menu = new JMenu("文件(F)");
 42         menu.setMnemonic('f'); // 助记符
 43 
 44         build = new JMenu("新建");
 45 
 46         file = new JMenuItem("文件");
 47         project = new JMenuItem("答题");
 48         item1 = new JMenuItem("保存(S)");
 49         item2 = new JMenuItem("退出");
 50 
 51         answer = new JLabel("第 1 题");
 52 
 53         // 添加菜单项至菜单上
 54         build.add(file);
 55         build.add(project);
 56 
 57         menu.add(build);
 58         menu.add(item1);
 59         menu.add(item2);
 60         menu.addSeparator();
 61         // 将菜单加入至菜单栏
 62         jm.add(menu);
 63 
 64         JPanel contentPanel = new JPanel();
 65         contentPanel.setLayout(null);
 66         JLabel daan = new JLabel("答案");
 67         JLabel dengyu = new JLabel("=");
 68         num_answer = answer;
 69         num_answer.setFont(new Font("宋体", Font.BOLD, 22));
 70         jb_next = new JButton("下一题");
 71         jta.setFont(new Font("宋体", Font.BOLD, 22));
 72         jta_answer.setFont(new Font("宋体", Font.BOLD, 22));
 73         jb_next.setFont(new Font("宋体", Font.BOLD, 22));
 74         daan.setFont(new Font("宋体", Font.BOLD, 22));
 75         dengyu.setFont(new Font("宋体", Font.BOLD, 22));
 76 
 77         contentPanel.add(num_answer);
 78         contentPanel.add(daan);
 79         contentPanel.add(dengyu);
 80         contentPanel.add(jta);
 81 
 82         contentPanel.add(jta_answer);
 83         contentPanel.add(answer_all);
 84         contentPanel.add(jb_next);
 85 
 86         num_answer.setBounds(90, 20, 130, 50);
 87         daan.setBounds(250, 20, 90, 50);
 88         jta.setBounds(50, 70, 150, 30);
 89         dengyu.setBounds(205, 70, 20, 20);
 90         jta_answer.setBounds(230, 70, 100, 30);
 91         jb_next.setBounds(350, 70, 110, 30);
 92         answer_all.setBounds(50, 120, 400, 300);
 93 
 94         this.setJMenuBar(jm); // 添加菜单栏，不能设定位置，会自动放在最上部
 95         this.add(contentPanel);
 96 
 97         this.setTitle("在线答题系统");
 98         this.setSize(600, 500);
 99         this.setVisible(true);
100         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
101         item1.addActionListener(new ActionListener() {
102             public void actionPerformed(ActionEvent arg0) {
103                 FileOutputStream outSTr = null;
104                 BufferedOutputStream Buff = null;
105                 boolean flag = true;
106                 File file;
107                 // String test ;
108                 do {
109                     // test = "test"+count;
110 
111                     String inputValue = JOptionPane.showInputDialog("Please input file name");
112                     file = new File(inputValue + "test.txt");
113                     if (!file.exists()) {
114                         // 创建文件
115                         try {
116 
117                             flag = file.createNewFile();
118 
119                         } catch (IOException e) {
120                             e.printStackTrace();
121 
122                         }
123                         flag = false;
124                     } else {
125 
126                         JOptionPane.showMessageDialog(null, "该文件名已存在，请重新输入", "ERROR", JOptionPane.ERROR_MESSAGE);
127                         flag = true;
128                     }
129                 } while (flag);
130                 // 写入文件
131                 String u_answer;
132                 try {
133                     outSTr = new FileOutputStream(file);
134                     Buff = new BufferedOutputStream(outSTr);
135                     System.out.println("选择是后执行的代码" + user_zongti.size() + user_answer.size());
136                     for (int i = 0; i < user_zongti.size(); i++) {
137                         try {
138                             Buff.write(user_zongti.get(i).getBytes());
139                             Buff.write("    ".getBytes());
140                             u_answer = user_answer.get(i);
141                             if (u_answer.equals(""))
142                                 u_answer = "没有作答";
143 
144                             Buff.write(u_answer.getBytes());
145                             Buff.write("
".getBytes());
146                         } catch (IOException e) {
147                             e.printStackTrace();
148                             i--;
149                         }
150                     }
151                     Buff.flush();
152                     Buff.close();
153 
154                 } catch (IOException e) {
155                     e.printStackTrace();
156                 }
157                 try {
158                     outSTr.close();
159                 } catch (IOException e) {
160                     e.printStackTrace();
161                 }
162                 user_zongti.clear();
163                 user_answer.clear();
164             }
165         });
166 
167         project.addActionListener(new ActionListener() {
168             public void actionPerformed(ActionEvent arg0) {
169                 arithmetic art = new arithmetic();
170                 true_answer = art.list_answer;
171                 jta_timu = art.list_timu;
172                 jta_zong = art.list;
173                 answer_count = 1;
174                 answer_all.setText("");
175                 for (int i = 0; i < art.list_timu.size(); i++) {
176                     user_zongti.add(jta_zong.get(i));
177                     answer_all.append(jta_timu.get(i));
178                     answer_all.append("
");
179                 }
180                 num_answer.setText("第 " + answer_count + " 题");
181                 jta.setText(jta_timu.get(answer_count - 1));
182                 answer_count++;
183 
184             }
185         });
186         jb_next.addActionListener(new ActionListener() {
187             public void actionPerformed(ActionEvent arg0) {
188                 String temp;
189                 temp = jta_answer.getText();
190 
191                 if (jta.getText().equals("")) {
192                     JOptionPane.showMessageDialog(null, "错误,请导入题库", "错误", JOptionPane.ERROR_MESSAGE);
193                     return;
194                 }
195                 jta_answer.setText("");
196                 if (answer_count <= 10) {
197                     if (isInteger(temp)) {
198 
199                         user_answer.add(temp);
200                         System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
201                         num_answer.setText("第 " + answer_count + " 题");
202                         jta.setText(jta_timu.get(answer_count - 1));
203                         answer_count++;
204                     } else {
205                         JOptionPane.showMessageDialog(null, "错误", "请输入数字", JOptionPane.ERROR_MESSAGE);
206                     }
207                 } else {
208                     user_answer.add(temp);
209                     System.out.println("选择否后执行的代码" + temp + "user_size" + user_answer.size());
210                     answer_fenshu = 0;
211                     for (int i = 0; i < user_answer.size(); i++) {
212                         if (user_answer.get(i).equals(true_answer.get(i)))
213                             answer_fenshu += 5;
214                     }
215                     user_fenshu.add(answer_fenshu);
216                     Object[] options = { "是", "取消" };
217                     int res = JOptionPane.showOptionDialog(null, "是否查看成绩", "答题完毕", JOptionPane.DEFAULT_OPTION,
218                             JOptionPane.YES_NO_OPTION, null, options, options[0]);
219                     if (res == JOptionPane.YES_OPTION) {
220                         chart ct = new chart(user_fenshu);
221                         ct.setVisible(true);
222 
223                     } else {
224                         Object[] option = { "是", "取消" };
225                         int res1 = JOptionPane.showOptionDialog(null, "是否退出程序", "终止框", JOptionPane.DEFAULT_OPTION,
226                                 JOptionPane.YES_NO_OPTION, null, option, option[0]);
227 
228                         if (res1 == JOptionPane.YES_OPTION) {
229                             dispose();
230                             System.exit(0);
231 
232                         } else {
233 
234                         }
235 
236                     }
237 
238                 }
239 
240             }
241         });
242 
243         item2.addActionListener(new ActionListener() {
244             public void actionPerformed(ActionEvent e) {
245                 dispose();
246                 System.exit(0);
247             }
248         });
249 
250     }
251 
252     public static boolean isInteger(String str) {
253         for (int i = str.length(); --i >= 0;) {
254             if (!Character.isDigit(str.charAt(i))) {
255                 return false;
256             }
257         }
258         return true;
259     }
260 }
    View Code
     1 package ui_test;
 2 
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         MyExGUI lg = new MyExGUI();
 7         //new MyExGUI();
 8 
 9     }
10 
11 }
    View Code
      1 package ui_test;
  2 
  3 import java.io.BufferedOutputStream;
  4 import java.io.File;
  5 import java.io.FileOutputStream;
  6 import java.io.IOException;
  7 import java.util.ArrayList;
  8 import java.util.Random;
  9 import java.util.Scanner;
 10 
 11 public class arithmetic {
 12     ArrayList<String> list = new ArrayList<String>();
 13     ArrayList<String> list_timu = new ArrayList<String>();
 14     ArrayList<String> list_answer = new ArrayList<String>();
 15 
 16     public arithmetic() {
 17         FileOutputStream outSTr = null;
 18         BufferedOutputStream Buff = null;
 19         int number_n = 10, count;
 20 
 21         ArrayList<String> list_temp = new ArrayList<String>();
 22         String[] operator = new String[] { "+", "-", "*", "/" };
 23 
 24         Random rand = new Random();
 25         File file1 = new File("test.txt");
 26         if (file1.exists()) {
 27             // 创建文件
 28             try {
 29                 file1.createNewFile();
 30             } catch (IOException e) {
 31                 e.printStackTrace();
 32             }
 33         }
 34 
 35         while (number_n > 0) {
 36             int[] number_temp = new int[rand.nextInt(2) + 3];
 37             String[] str_temp = new String[number_temp.length - 1];
 38             for (int i = 0; i < number_temp.length; i++) {
 39                 if (i < number_temp.length - 1) {
 40                     number_temp[i] = rand.nextInt(100);
 41                     list_temp.add(String.valueOf(number_temp[i]));
 42                     str_temp[i] = operator[rand.nextInt(4)];
 43                     list_temp.add(str_temp[i]);
 44 
 45                 }
 46 
 47                 else {
 48                     number_temp[i] = rand.nextInt(100);
 49                     list_temp.add(String.valueOf(number_temp[i]));
 50                 }
 51             }
 52 
 53             count = calculate_RPN(produce_RPN(list_temp));
 54             if (count != -1) {
 55                 list_timu.add(transform_string(list_temp));
 56                 list_answer.add(String.valueOf(count));
 57                 list_temp.add(" = " + count);
 58                 list.add(transform_string(list_temp));
 59                 number_n--;
 60                 list_temp.clear();
 61             } else
 62                 list_temp.clear();
 63             System.out.println(number_n);
 64 
 65         }
 66         try {
 67             outSTr = new FileOutputStream(file1);
 68             Buff = new BufferedOutputStream(outSTr);
 69             for (int i = 0; i < list.size(); i++) {
 70                 try {
 71                     Buff.write(list.get(i).getBytes());
 72                     Buff.write("
".getBytes());
 73                 } catch (IOException e) {
 74                     e.printStackTrace();
 75                     i--;
 76                 }
 77             }
 78             Buff.flush();
 79             Buff.close();
 80 
 81         } catch (IOException e) {
 82             e.printStackTrace();
 83         }
 84         // Buff.close();
 85         try {
 86             outSTr.close();
 87         } catch (IOException e) {
 88             e.printStackTrace();
 89         }
 90 
 91         for (int i = 0; i < list.size(); i++) {
 92             System.out.print(list.get(i));
 93             System.out.println();
 94         }
 95         System.out.print("计算完毕！");
 96 
 97     }
 98 
 99     public static int calculate_RPN(ArrayList<String> list_temp) {
100         int i = 0, t;
101         double a = 0, b = 0;
102         String l_temp;
103         Stack sk = new Stack(10);
104         for (t = 0; t < list_temp.size(); t++) {
105             l_temp = list_temp.get(i++);
106             if (!isInteger(l_temp)) {
107                 b = sk.mypop();
108                 a = sk.mypop();
109                 switch (l_temp) {
110                 case "+":
111                     sk.mypush(a + b);
112                     break;
113                 case "-":
114                     if(!(a<b)) {
115                     sk.mypush(a - b);
116                     }
117                     else
118                         return -1;
119                     break;
120                 case "*":
121                     sk.mypush(a * b);
122                     break;
123                 case "/":
124                     if (b == 0||a<b)
125                         return -1;
126                     sk.mypush(a / b);
127                     break;
128                 }
129                 System.out.println("st.mytop: " + sk.mypeek());
130             } else {
131                 sk.mypush((double) Integer.parseInt(l_temp));
132             }
133 
134         }
135         if (!sk.myisempty()) {
136             a = sk.mypop();
137             b = a - (int) a;
138             System.out.println("a:  " + a);
139             if (a > 0 && b == 0) {
140                 return (int) a;
141             } else
142                 return -1;
143         } else
144             return -1;
145 
146     }
147 
148     public static ArrayList<String> produce_RPN(ArrayList<String> list_temp) {
149         int t = 0, i = 0;
150         String tmp;
151         Tack mytack = new Tack(10);
152         ArrayList<String> lt_temp = new ArrayList<String>();
153         while (true) {
154             tmp = list_temp.get(i++);
155             if (isInteger(tmp)) {
156                 lt_temp.add(tmp);
157             } else {
158                 if (mytack.myisempty()) {
159                     mytack.mypush(tmp);
160                 }
161 
162                 else {
163                     if (isCPriority(tmp, mytack.mypeek()))
164                         mytack.mypush(tmp);
165                     else {
166                         lt_temp.add(mytack.mypop());
167                         mytack.mypush(tmp);
168                     }
169 
170                 }
171             }
172             if (i >= list_temp.size()) {
173                 while (!mytack.myisempty())
174                     lt_temp.add(mytack.mypop());
175                 System.out.println(transform_string(list_temp));
176                 list_temp = lt_temp;
177                 System.out.println(list_temp);
178                 return list_temp;
179             }
180         }
181 
182     }
183 
184     public static boolean isInteger(String str) {
185         for (int i = str.length(); --i >= 0;) {
186             if (!Character.isDigit(str.charAt(i))) {
187                 return false;
188             }
189         }
190         return true;
191     }
192 
193     public static boolean isCPriority(String str, String s) {
194         if ((str + s).equals("*+") || (str + s).equals("*-") || (str + s).equals("/+") || (str + s).equals("/-"))
195             return true;
196         else
197             return false;
198     }
199 
200     public static String transform_string(ArrayList<String> list_temp) {
201         String s = "";
202         for (int i = 0; i < list_temp.size(); i++) {
203             s += list_temp.get(i);
204         }
205         return s;
206 
207     }
208 
209     static class Stack {
210         int mytop;
211         double stk[];
212 
213         public Stack(int num) {
214             mytop = -1;
215             stk = new double[num];
216         }
217 
218         /* 出栈 */
219         double mypop() {
220             double peek = stk[mytop];
221             mytop--;
222             return peek;
223         }
224 
225         /* 入栈 */
226         void mypush(double x) {
227             mytop++;
228             stk[mytop] = x;
229 
230         }
231 
232         /* 判空 */
233         Boolean myisempty() {
234             if (mytop == -1)
235                 return true;
236             else
237                 return false;
238         }
239 
240         /* 取栈顶元素 */
241         double mypeek() {
242             double peek = stk[mytop];
243             return peek;
244         }
245 
246         /* 栈大小 */
247         int mysize() {
248             return mytop + 1;
249         }
250     }
251 
252     static class Tack {
253         int mytop;
254         String tk[];
255 
256         public Tack(int num) {
257             mytop = -1;
258             tk = new String[num];
259         }
260 
261         /* 出栈 */
262         String mypop() {
263             String peek = tk[mytop];
264             mytop--;
265             return peek;
266         }
267 
268         /* 入栈 */
269         void mypush(String x) {
270             mytop++;
271             tk[mytop] = x;
272 
273         }
274 
275         /* 判空 */
276         Boolean myisempty() {
277             if (mytop == -1)
278                 return true;
279             else
280                 return false;
281         }
282 
283         /* 取栈顶元素 */
284         String mypeek() {
285             String peek = tk[mytop];
286             return peek;
287         }
288 
289         /* 栈大小 */
290         int mysize() {
291             return mytop + 1;
292         }
293 
294     }
295 
296 }
297 
298 
299 arithmetic
    View Code
     1 package ui_test;
 2 
 3 import java.awt.Color;  
 4 import java.awt.Graphics;  
 5 import java.awt.Graphics2D;
 6 import java.util.ArrayList;
 7 import java.util.Random;  
 8   
 9 import javax.swing.JFrame;
10   
11 public class chart extends JFrame{
12       //绘制柱形统计图  
13         ArrayList<Integer> ran=new  ArrayList<Integer>();
14         public chart(ArrayList<Integer> scores)
15         {  
16             super();  
17             getContentPane().setForeground(Color.CYAN);
18             setForeground(Color.CYAN);
19             setBackground(Color.CYAN);
20             for(int i=0;i<scores.size();i++)
21             {
22                 ran.add(scores.get(i));
23                 System.out.println(scores.get(i));
24             }
25               
26             setTitle("绘制柱形图");  
27             setSize(600, 400);
28             setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
29         }  
30         @Override  
31         public void paint(Graphics g){
32             int Width = getWidth();
33             int Height = getHeight();
34             int leftMargin = 20;//柱形图左边界
35             int topMargin = 50;//柱形图上边界
36             Graphics2D g2 = (Graphics2D) g;
37             g2.setColor(Color.WHITE);//绘制白色背景
38             g2.fillRect(0, 0, Width, Height-100);//绘制矩形图
39             g2.setColor(Color.black);
40              for(int i=0;i<=10;i++)
41              {
42                  //绘制灰色横线和百分比
43                  g2.drawString((100-10*i)+" ", 15, topMargin+30*i);
44                  g2.drawLine(10, topMargin+30*i, Width, topMargin+30*i);//绘制灰色横线
45              }
46              g2.setColor(Color.RED);
47              for(int i=0;i<=ran.size();i++)
48              {
49                  //绘制柱形图
50                  int step = (i+1)*40;//设置每个柱形图的水平间隔为40
51                  //绘制矩形
52                  g2.fillRoundRect(leftMargin+step*2-5,(100-ran.get(i))*3+50, 40, 300-(100-ran.get(i))*3, 40, 10);
53                  //列出测试轮数
54                  g2.drawString("第"+(i+1)+"轮", leftMargin+step*2, 380);
55              }    
56          }  
57 
58     
59 }
60 
61 
62 chart
    View Code

    任务3：本学期课程已结束，请汇总《面向对象程序设计课程学习进度条》的数据，统计个人专业能力提升的数据。并从学习内容、学习方法、学习心得几个方面进行课程学习总结，也希望你对课程的不足提出建议和意见。

    实验总结：

    总复习纲要
     Java语言特点与开发环境配置（第1章、第2章）
     Java基本程序结构（第3章）
     Java面向对象程序结构（第4章、第5章、第6章）
     类、类间关系、类图
     Java JDK预定义类/接口及其API（String-第3章、
    Arrays-第3章、Files-第3章62页、LocalDate-第4章、
    Object-第5章、对象包装器-第5章、Comparator-第6章、
    异常类-第7章、ArrayList-第5+8章、第第9章、第10-12章、
    第14章）
    — Java异常处理编程模型
    — Java GUI编程模型
     Java并发程序设计（第14章）
     Java应用程序部署（第13章）

    JAVA特点

    简单的、面向对象的、分布式的、强壮的、安全的、
    体系结构中立的、可移植的、解释型的、高性能的、
    多线程的、动态的语言。

    JDK的安装及配置
    JDK平台提供的Java编译器（javac.exe）和
    Java解释器（java.exe）位于Java安装目录的
    bin文件夹中，为了能在任何目录中使用编译器
    和解释器，应在系统特性中设置Path

     

     JDK的安装及配置

    JDK安装目录的jre文件夹中包含着Java应用程
    序运行时所需要的Java类库，这些类库被包含在jrelib目录下的压缩文件rt.jar中

      

    一个Java程序的开发过程 

     

     源文件的命名规则

    如果源文件中有多个类，那么只能有一个类是public类。如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是.java。 如果源文件没有public类，那么源文件的名字只要和某个类的名字相同，并且扩展名是.java就可以了。 标识符、关键字和数据类型

     Java标识符的组成
    熟悉Java关键字 Java数据类型     Java一维数组的定义、初始化和数组元素   的引用Java数据类型

    运算符与表达式        

    算术运算符，关系运算符，逻辑运算符，位运算符，赋值运算符，其他运算符

    Java流程控制语句

     控制语句， if语句， switch语句， 循环语句， while， do…while， for，break和continue语句， break——跳出switch结构；终止并跳出循环体。， continue——结束本次循环。

    类、对象、继承和接口

     类声明
    class People
    {
    …
    }
     类体内容由两部分构成：
     类成员变量：用来刻画类属性；
     类成员方法：用来刻画类内操作。

    局部变量
    – 在方法体中定义的变量和方法的参数被称为局部变量。 类成员变量和局部变量的区别 类成员变量在整个类内都有效，局部变量只在定义它的方法内有效。
     如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏。

    类成员方法
    —方法的定义包括两部分：方法声明和方法体。
    构造方法
    —名字必须与类名完全相同，没有返回值类型；
    —构造方法可以重载；
    —每个类至少有一个构造方法，若程序员没有定义构造方法，系统会自动产生一个默认构造方法，这个默认构造方法无参数，方法体为空；
    —程序员为类定义了构造方法，系统就不再提供默认构造方法；
    — 用途：初始化类对象。

    方法重载
    —一个类中可以有多个具有相同的名字的方法。但这些方法或者是参数的个数不同，或者是参数的类型不同创建对象需两个步骤：对象声明和为对象分配内存
    —对象声明格式为：
    类名 对象名字;
    如：People zhangPing;
    —为声明对象分配内存格式如下：
    对象名= new 构造方法名(参数表);
    如： zhangPing=new People();
    —对象创建常用格式为：
    类名 对象名= new 构造方法名(参数表);;类、对象、继承和接口 通过使用运算符“.”，对象可以实现对所属类具有访问权限的成员变量访问和成员方法调用。 没有分配内存的对象称作空对象，空对象不能使用，即不能让空对象去调用方法。类、对象、继承和接口
    Static关键字
    – 用static修饰的成员变量称为类（静态）变量
    – 用static修饰的方法称为类（静态）方法
    实例变量和类变量的区别
    – 如果类的成员变量有类变量，那么该类所有对象的类变量内存是相同的。
    – 具有访问权限的类变量可以通过某个对象访问，也可
    以通过类名访问。
    – 具有访问权限的实例变量仅可以通过对象访问，不能使用类名访问。类、对象、继承和接口实例方法和类方法的区别
    – 实例方法可以被类创建的任何对象调用执行。
    – 类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用 。
    说明：
    - 类方法可以调用其它类方法
    - 类方法只能访问static成员变量
    - 类方法不能以任何形式引用this和super
    - 实例方法既可以访问实例成员变量也可访问类成员变量
    - 实例方法既可以调用实例方法也可以调用类方法
    this关键字
    - this表示类的当前对象。
    - this可以出现在实例方法和构造方法中，但不可以出现在类方法中。
    - this关键字出现在构造方法中时，代表使用该构造方法所创建的对象。
    - this出现在类的实例方法中时，代表正在调用该方法的当前对象。
    实现类继承的方式
    在类的声明中，通过使用关键字extends来创建一个类的子类，格式如下:
    class 子类名 extends 父类名
    {
    …
    }
    类、对象、继承和接口
    继承的规定
    - Java只支持单继承，不允许多继承
    - Java允许有多层继承

    方法的重写
    - 方法重写是指：子类中定义一个方法，这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。
    - 子类重写父类，被重写的方法不能比父类拥有更严格的访问权限方法重载与方法重写的区别 

     成员变量的隐藏
    - 子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量 。
    super关键字
    - 子类中访问父类中被隐藏的成员变量
    - super.成员变量
    - 子类调用父类中的方法
     调用父类中的特定构造方法
    super()
     调用父类中被重写的方法
    super.方法()
    类、对象、继承和接口
    子类对象与父类对象之间的转换
    - 子类对象向父类对象转换,自动转型 父类对象=子类对象
    - 父类对象向子类对象转换,强制转型 子类对象=（子类）父类对象类、对象、继承和接口多态性有两种表现形式：
    ①方法的多态性（方法重载）
    ②对象的多态性
    对象多态性是在继承应用上的一种扩展类、对象、继承和接口final关键字
    - final关键子可修饰类、方法成员、成员变量和方法中的参数。
    - final类不能被继承，即不能有子类
    - 方法被修饰为final方法，则这个方法不能被重写。
    - 一个成员变量被修饰为final的，就是常量，常量必须赋给初值，而且不能再发生变化。
    - 方法的参数被修饰为final的，该参数的值不能被改变。
    类、对象、继承和接口
    抽象类
    - 用关键字abstract修饰的类称为abstract类（抽象类）。
    abstract class A
    {
    „
    }
    - abstract类不能被实例化；
    - abstract类可以有abstract方法；
    - 对于abstract方法，只允许声明，不允许实现，且要用
    abstract关键字进行修饰；
    - 抽象类的子类必须重写所有的抽象方法。
    类、对象、继承和接口
    Java语言不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。

    成员变量的隐藏
    - 子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量 。
    super关键字
    - 子类中访问父类中被隐藏的成员变量
    - super.成员变量
    - 子类调用父类中的方法
     调用父类中的特定构造方法
    super()
     调用父类中被重写的方法
    super.方法()
    子类对象与父类对象之间的转换
    - 子类对象向父类对象转换,自动转型 父类对象=子类对象
    - 父类对象向子类对象转换,强制转型 子类对象=（子类）父类对象
    多态性有两种表现形式：
    ①方法的多态性（方法重载）
    ②对象的多态性
    对象多态性是在继承应用上的一种扩展
    final关键字
    - final关键子可修饰类、方法成员、成员变量和方法中的参数。
    - final类不能被继承，即不能有子类
    - 方法被修饰为final方法，则这个方法不能被重写。
    - 一个成员变量被修饰为final的，就是常量，常量必须赋给初值，而且不能再发生变化。
    - 方法的参数被修饰为final的，该参数的值不能被改变。类、对象、继承和接口
    抽象类
    - 用关键字abstract修饰的类称为abstract类（抽象类）。
    abstract class A
    {
    „
    }
    - abstract类不能被实例化；
    - abstract类可以有abstract方法；
    - 对于abstract方法，只允许声明，不允许实现，且要用
    abstract关键字进行修饰；
    - 抽象类的子类必须重写所有的抽象方法。、对象、继承和接口
    Java语言不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。

    接口的声明与使用
    - 关键字interface来定义一个接口。
    - 接口的定义与类的定义相似，包括接口的声明和接口体。
    - 接口体中包含常量定义和抽象方法定义两部分。
    如： interface Printable {
    int MAX=100;
    float sum(float x ,float y);
    }
    接口使用规则
    - 一个类可以实现多个接口；
    - 如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体。
    class 类名 implements 接口A，接口B
    {
    …
    }

    一个新的接口用extends关键字去继承一个已有的接口，实现接口的多继承
    interface 接口A extends 接口1，接口2，接口3，接口4
    {
    …
    }

     接口与抽象类的区别 

     package语句
    - 必须是源文件中的第一条语句。在package语句之前，除了空白和注释之外不能有任何语句。
    - 如果不加package语句，则指定为缺省包或无名包。
    - 包对应着文件系统的目录层次结构。
    - 在package语句中，用“.”来指明包（目录）的层次。
    类、对象、继承和接口
    引入包中的类
    import java.io.File;
    引入整个包
    import java.io.*;
    java默认导入的包
    java.lang.*
    在同一包中的类可以互相引用，无需import语句。
    类的访问权限修饰符
    - public
    当两个类不在同一个包中时，允许外部类访问
    - default 不能让不同包的外部类访问，但可以在同一个包中不同类之间访问类的其它修饰符
    - final
    - abstract
    方法的权限访问修饰符
    - public
    - protected
    - default(不加访问说明符时)
    - private 方法的其它修饰符
    - static
    - final
    - abstract
    - synchronized（多线程中介绍） 

    public protected default privat


    内部类
    - Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。
    - 内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。
    匿名内部类
    - 匿名内部类没有类名，所以创建匿名内部类时同时创建匿名内部类的对象
    - 创建匿名内部类的语法格式如下所示

    Lambda表达式
    - Java 8 引入的一个新的功能，主要用途是提供一个函数化的语法来简化编码。
    - Lambda表达式本质上是一个匿名方法。 

    类、类间关系、类图

    类和类之间关系： is a，has a, use a
    - is a： 继承，实现关系
    - has a： 组合，聚合，关联关系
    - use a： 依赖关系
    继承关系
    实现关系
    public class Animal{}
    public class Dog extends Animal{}
    public interface UserService{}
    public class UserService implements UserService{}
    组合关系
    public class Heart{}
    publid class Stomach{}
    public class Person{
    private Heart heart;
    private Stomach stomach;
    public Person(){
    this.heart=new Heart();
    this.stomach=new Stomach();
    }
    }
    聚合关系
    public class Engine{}
    public class Gearbox{}
    publicc lass Car{
    private Engine engine;
    private Gearbox gearbox;
    public Car(Engine engine, Gearbox gearbox){
    this.engine=engine;
    this. gearbox=gearbox;
    }
    }
    关联关系
    public class Car{}
    public class Person{
    private Car car;
    public void setCar(){
    this.car=car;
    }
    }
    依赖关系
    public class Train{
    public void move(){}
    }
    public class Person{
    public void move(Train train){
    train.move();
    }
    }
    类图：在OO程序设计中，进行类关系分析与设计的工具
     

    JDK预定义类及其API

    JDK中预定义类API使用要求：
    - 导入类所在的包；
    - 掌握预定义类的名称及其用途；
    - 掌握预定义类中定义的常用方法、方法参数要求、返回值类型

    异常处理编程模型

    捕获异常编程框架
    try
    {
    //此处是可能出现异常的代码
    }
    catch(Exception e)
    {
    //此处是如果发生异常的处理代码
    }
    finally
    {
    //此处是肯定被执行的代码
    }

     抛出异常
    - throws语句是在方法的声明中使用来抛出异常，用来指定方法可能抛出异常，但不想在当前方法中处理这个异常。
    - throw语句是在方法体内使用抛出异常类的对象，程序在执行到throw语句时立即终止，它后面的语句都不执行。
    - 要捕捉throw抛出的异常，则必须使用try-catch语句。
    异常处理编程模型
     创建自定义异常类(*)
    定义 extends Exception的子类
    异常处理
    Java GUI编程模型
    掌握java.awt和java.swing包中各种

     GUI定义需
    要的组件创建以及常用方法
    Java中的事件处理机制
    - 事件由用户操作某个组件对象产生，被操作组件称为事件源。
    - 一个组件能响应哪些事件，响应事件后需执行的语句序列存放在什么位置，这些功能由事件监视器负责。
    - 事件监视器是某个实现了监听器接口类的对象。

    -创建GUI中事件源，开发程序时，程序员需要做以下2件事：
     向事件源注册事件监视器
    例如，文本框的事件监听器注册方法是：
    addActionListener(监视器);
     创建该监视器对象的类，声明实现相应的接口 在类中实现接口中要求的事件处理方法
    Java GUI编程模型
     Java中的每个事件类都有一个相应的监视器接口，接口中声明了一个或多个抽象的事件处理方法。如果一个类实现事件监视器接口，其对象就可以作为对应事件的监视器，具备监视和处理事件的能力。
    Java GUI编程模型
    GUI设计中编写事件处理程序代码
    必须确定事件源与事件监视器事件源的选择通常比较容易，事件监视器必须是实现事件监视器接口的类对象
    Soureobject.addXXXListener(监视器)，将某个对象作为自己的监视器创建监视器对象的类必须实现相应的事件接口
    Class A implements XXXListener
    当事件源发生事件时，监视器将调用接口中的相应方法对事件进行处理
  • 相关阅读:
    OpenLayer学习之图文标注
    HTML5制作时钟（canvas）
    ADO,NET中简单三层SQLHelper封装介绍
    OpenLayer学习之加载天地图
    ArcGIS Server manger管理页面无法打开问题解决
    Java EE (14) -- SSH配置
    R语言实战读书笔记(一)R语言介绍
    Machine Learning for hackers读书笔记_一句很重要的话
    Machine Learning for hackers读书笔记(十二)模型比较
    Machine Learning for hackers读书笔记(十)KNN：推荐系统
  • 原文地址：https://www.cnblogs.com/wy201771010126/p/10198998.html
Copyright © 2011-2022 走看看