201771010135 杨蓉庆《面对对象程序设计（java）》第十八周学习总结
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）点击窗口关闭，程序退出。
import java.awt.EventQueue;
import javax.swing.JFrame;
public class Main {
public static void main(String[] args) {
EventQueue.invokeLater(() -> {
DemoJFrame page = new DemoJFrame();
});
}
}
Main
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.Window; public class WinCenter {
public static void center(Window win){
Toolkit tkit = Toolkit.getDefaultToolkit();
Dimension sSize = tkit.getScreenSize();
Dimension wSize = win.getSize();
if(wSize.height > sSize.height){
wSize.height = sSize.height;
}
if(wSize.width > sSize.width){
wSize.width = sSize.width;
}
win.setLocation((sSize.width - wSize.width)/ 2, (sSize.height - wSize.height)/ 2);
}
}
WinCenter
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
public class DemoJFrame extends JFrame {
public DemoJFrame() {
JPanel panel1 = new JPanel();
panel1.setPreferredSize(new Dimension(700, 45));
panel1.setLayout(new GridLayout(1, 4));
JLabel label1 = new JLabel("Name:");
JTextField j1 = new JTextField("");
JLabel label2 = new JLabel("Qualification:");
JComboBox<Object> j2 = new JComboBox<>();
j2.addItem("chuzhong");
j2.addItem("gaozhong");
j2.addItem("undergraduate");
panel1.add(label1);
panel1.add(j1);
panel1.add(label2);
panel1.add(j2); JPanel panel2 = new JPanel();
panel2.setPreferredSize(new Dimension(700, 65));
panel2.setLayout(new GridLayout(1, 4));
JLabel label3 = new JLabel("Address:");
JTextArea j3 = new JTextArea();
JLabel label4 = new JLabel("Hobby:");
JPanel p = new JPanel();
p.setLayout(new GridLayout(3, 1));
p.setBorder(BorderFactory.createLineBorder(null));
JCheckBox c1 = new JCheckBox("Reading");
JCheckBox c2 = new JCheckBox("Singing");
JCheckBox c3 = new JCheckBox("Dancing");
p.add(c1);
p.add(c2);
p.add(c3);
panel2.add(label3);
panel2.add(j3);
panel2.add(label4);
panel2.add(p); JPanel panel3 = new JPanel();
panel3.setPreferredSize(new Dimension(700, 150));
FlowLayout flowLayout1 = new FlowLayout(FlowLayout.LEFT, 70, 40);
panel3.setLayout(flowLayout1);
JLabel label5 = new JLabel("Sex:");
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(2,1));
p1.setBorder(BorderFactory.createLineBorder(null));
ButtonGroup bu = new ButtonGroup();
JRadioButton jr1 = new JRadioButton("Male");
JRadioButton jr2 = new JRadioButton("Female");
bu.add(jr1);
bu.add(jr2);
p1.add(jr1);
p1.add(jr2);
panel3.add(label5);
panel3.add(p1);
add(panel1);
add(panel2);
add(panel3); JPanel panel4 = new JPanel();
panel4.setPreferredSize(new Dimension(700, 150));
JButton b1 = new JButton("Validate");
panel4.add(b1);
JButton b2 = new JButton("Reset");
panel4.add(b2);
add(panel4); FlowLayout flowLayout = new FlowLayout();
this.setLayout(flowLayout);
this.setTitle("Students Detail");
this.setBounds(300, 300, 800, 400);
this.setVisible(true);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE); b1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {
// TODO 自动生成的方法存根
String xueli = j2.getSelectedItem().toString();
System.out.println("Name:" + j1.getText());
System.out.println("Qualification:" + xueli);
String hobbystring = "Hobby:";
if (c1.isSelected()) {
hobbystring += "Reading";
}
if (c2.isSelected()) {
hobbystring += "Singing";
}
if (c3.isSelected()) {
hobbystring += "Dancing";
}
System.out.println("Address:" + j3.getText());
if (jr1.isSelected()) {
System.out.println("Sex:Male");
}
if (jr2.isSelected()) {
System.out.println("Sex:Female");
}
System.out.println(hobbystring);
}
});
b2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {
// TODO 自动生成的方法存根
j1.setText(null);
j3.setText(null);
j2.setSelectedIndex(0);
c1.setSelected(false);
c2.setSelected(false);
c3.setSelected(false);
bu.clearSelection();
}
});
} public static void main(String args[]) {
new DemoJFrame();
} }
DemoJFrame
结果如下：
练习2：采用GUI界面设计以下程序：
l 编制一个程序，将身份证号.txt 中的信息读入到内存中；
l 按姓名字典序输出人员信息；
l 查询最大年龄的人员信息；
l 查询最小年龄人员信息；
l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
l 查询人员中是否有你的同乡。
l 输入身份证信息，查询所提供身份证号的人员信息，要求输入一个身份证数字时，查询界面就显示满足查询条件的查询结果，且随着输入的数字的增多，查询匹配的范围逐渐缩小。
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.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner; public class Main{
private static ArrayList<Student> studentlist;
public static void main(String[] args) {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("D:\\text");
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();
}
boolean isTrue = true;
while (isTrue) {
System.out.println("选择你的操作，输入正确格式的选项");
System.out.println("A.字典排序");
System.out.println("B.输出年龄最大和年龄最小的人");
System.out.println("C.寻找老乡");
System.out.println("D.寻找年龄相近的人");
System.out.println("F.退出");
String m = scanner.next();
switch (m) {
case "A":
Collections.sort(studentlist);
System.out.println(studentlist.toString());
break;
case "B":
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;
} }
System.out.println("年龄最大："+studentlist.get(k1));
System.out.println("年龄最小："+studentlist.get(k2));
break;
case "C":
System.out.println("老家?");
String find = scanner.next();
String place=find.substring(0,3);
for (int i = 0; i <studentlist.size(); i++)
{
if(studentlist.get(i).getprovince().substring(1,4).equals(place))
System.out.println("老乡"+studentlist.get(i));
}
break; case "D":
System.out.println("年龄：");
int yourage = scanner.nextInt();
int near=agenear(yourage);
int value=yourage-studentlist.get(near).getage();
System.out.println(""+studentlist.get(near));
break;
case "F":
isTrue = false;
System.out.println("退出程序!");
break;
default:
System.out.println("输入有误"); }
}
}
public static int agenear(int age) {
int j=0,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;
} }
main
public class Student implements Comparable<Student> {
private String name;
private String number ;
private String sex ;
private int age;
private String province;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getnumber() {
return number;
}
public void setnumber(String number) {
this.number = number;
}
public String getsex() {
return sex ;
}
public void setsex(String sex ) {
this.sex =sex ;
}
public int getage() {
return age;
}
public void setage(int age) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getprovince() {
return province;
}
public void setprovince(String province) {
this.province=province ;
}
public int compareTo(Student o) {
return this.name.compareTo(o.getName());
}
public String toString() {
return name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
}
}
Student
j结果如下：
练习3：采用GUI界面设计以下程序
l 编写一个计算器类，可以完成加、减、乘、除的操作
l 利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
l 将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt。
package 答题; import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.Random;
import javax.swing.*; public class Exam extends JFrame {
JPanel p=new JPanel();
JLabel timeLabel=new JLabel(); JLabel[] label1=new JLabel[10];
JLabel[] label2=new JLabel[10];
JLabel[] label3=new JLabel[10];
JLabel[] label4=new JLabel[10];
JLabel[] label5=new JLabel[10];
JTextField[] field=new JTextField[10];
JLabel[] label6=new JLabel[10];
String[] btn_name= {"开始","重置","提交","重考"};
JButton[] btn=new JButton[4];
Panel2 panel2=null;
int ExamCount=0;
JLabel examLabel=new JLabel();
double[] result=new double[10];
public static void main(String[] args) {
new Exam("测试").setVisible(true);
} public Exam(String title) {
setTitle(title);
setLocationRelativeTo(null);
setDefaultCloseOperation(3);
setSize(400,500);
setResizable(false);
setForeground(Color.blue);
add(new Panel1(),BorderLayout.NORTH);
panel2=new Panel2();
add(new JScrollPane(panel2));
add(new Panel3(),BorderLayout.WEST);
} int rightResultCount=0;
public void startExam() {
int num1=0;
int num2=0;
String[] quots= {"+","-","*","/"};
String quot=null;
Random ran=null;
ran=new Random(System.currentTimeMillis());
Box box=Box.createVerticalBox(); for(int i=0;i<10;i++) {
num1=ran.nextInt(100)+1;
num2=ran.nextInt(100)+1;
int n=ran.nextInt(4);
quot=new String(quots[n]);
switch(quot) {
case "+":
result[i]=num1+num2;
break;
case "-":
result[i]=num1-num2;
break;
case "*":
result[i]=num1*num2;
break;
case "/":
result[i]=num1/(num2*1.0);
result[i]=Math.round(result[i]*100)/100.0;
break;
} label1[i]=new JLabel("第"+(i+1)+"题：");
label2[i]=new JLabel(num1+""); label3[i]=new JLabel(quot);
label4[i]=new JLabel(num2+"");
label5[i]=new JLabel("=");
field[i]=new JTextField();
field[i].setPreferredSize(new Dimension(60,20));
field[i].addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent ee) {
if((ee.getKeyChar()>'9' || ee.getKeyChar()<'0') && ee.getKeyChar()!=45 && ee.getKeyChar()!='.') {
ee.consume();
}
}
});
label6[i]=new JLabel("");
Box hbox=Box.createHorizontalBox();
hbox.add(label1[i]);
hbox.add(Box.createHorizontalStrut(20));
hbox.add(label2[i]);
hbox.add(Box.createHorizontalStrut(5));
hbox.add(label3[i]);
hbox.add(Box.createHorizontalStrut(5));
hbox.add(label4[i]);
hbox.add(Box.createHorizontalStrut(5));
hbox.add(label5[i]);
hbox.add(Box.createHorizontalStrut(5));
hbox.add(field[i]);
hbox.add(Box.createHorizontalStrut(20));
hbox.add(label6[i]);
box.add(hbox);
box.add(Box.createVerticalStrut(20));
}
panel2.add(box);
panel2.validate();
}
int submitCount=0;
class Listener implements ActionListener{
public void actionPerformed(ActionEvent e) {
JButton button=(JButton)e.getSource();
if(button==btn[0]) {
startExam();
ExamCount++;
btn[0].setEnabled(false); for(int i=1;i<4;i++) {
btn[i].setEnabled(true);
}
}
if(button==btn[1]) {
for(int i=0;i<10;i++) {
field[i].setText("");
}
}
if(button==btn[2] ) {
rightResultCount=0;
btn[2].setEnabled(false);
double yourResult=0;
for(int i=0;i<10;i++) {
try {
yourResult=Double.parseDouble(field[i].getText().trim());
}catch(Exception ee) {} if(yourResult==result[i]) {
rightResultCount++;
label6[i].setText("V");
label6[i].setForeground(Color.BLUE); }else {
label6[i].setText("X");
label6[i].setForeground(Color.RED); }
}
examLabel.setText("你答对了 "+rightResultCount+
" 道题，答错了"+(10-rightResultCount)+" 道题！"+
"考试得分是： "+rightResultCount*10+" 分！");
}
if(button==btn[3]) {
btn[2].setEnabled(true);
panel2.removeAll();
startExam();
ExamCount++;
btn[3].setEnabled(false);
for(int i=0;i<10;i++) {
field[i].setText("");
label6[i].setText("");
}
panel2.repaint();
}
if(btn[2].isEnabled()==false && btn[3].isEnabled()==false) {
btn[1].setEnabled(false);
}
}
} class Panel1 extends JPanel{
public Panel1() {
setPreferredSize(new Dimension(350,120));
setLayout(new GridLayout(3,1,10,10));
JTextArea area=new JTextArea("点击“开始”开始答题，答案中有小数的，保留2位！");
area.setLineWrap(true);
area.setEditable(false);
add(area);
add(examLabel);
p.add(timeLabel);
add(p);
}
} class Panel2 extends JPanel{
public Panel2() {
setPreferredSize(new Dimension(400,600));
}
} class Panel3 extends JPanel{
public Panel3() {
setPreferredSize(new Dimension(50,100));
setBackground(Color.LIGHT_GRAY);
for(int i=0;i<4;i++) {
btn[i]=new JButton(btn_name[i]);
btn[i].addActionListener(new Listener());
add(btn[i]);
if(i>0) {
btn[i].setEnabled(false);
}
}
}
}
}
Exam
任务3：本学期课程已结束，请汇总《面向对象程序设计课程学习进度条》的数据，统计个人专业能力提升的数据。并从学习内容、学习方法、学习心得几个方面进行课程学习总结，也希望你对课程的不足提出建议和意见。
学习总结：
1、OOPS主要优点：
- 封装：封装提供了对象之间的一种合约，这种合约确定对象自身内部隐藏什么，向彼此暴露什么。在Java中，我们可以使用private访问修饰符来隐藏方法和变量，从而制约来自外部世界的访问。 Java也提供了不同的访问修饰符如public(默认)，protected和private，在不同的隐藏水平使用，但目标是封装一些不需要改变的东西。按照最佳实践 - 一个类应该只有一个理由去改变，封装实现的“一个理由”的设计原则。
封装意味着隐藏预期会经常改变的一些东西，以避免这种改变破坏其它类。 - 继承：继承的主要优点是，它提供了代码重用和避免重复继承的正式机制，这也会导致紧耦合的设计，因为如果你要更改的超类，你必须知道子类的所有细节。
好处：提高了可复用性
- 创建了逻辑上的"is a"关系，如 Dog is a animal
- 模块化代码
- 避免重复
~多态性：多态性是一种（编程时）对于不同基础形式（数据类型）呈现相同接口的能力。这意味着类有不同的功能，同时共享一个通用的接口，可以通过传递特定类别的参考动态调用。典型的例子是Shape类和所有可以继承它（方形，圆形，十二面体，不规则的多边形，图示等）的类。每个类都有一个 Draw ()方法。
好处如下：
- 创建可重用的代码:多态性意味着一旦类被创建 实现和测试，它就能容易地被使用，而无需关注类的内部写的是什么
- 它提供更多泛型和松耦合代码
- 编译时间更少，且允许更快地开发
- 动态绑定:
- 一些接口能够使用不同实现方式创建。
- 能够使用同样的方法签名完全替代实现。
- 抽象：
基类的行为（即方法）和状态（即变量）可以在其派生子类中访问。继承的主要优点是，它提供了代码重用和避免重复继承的正式机制，这也会导致紧耦合的设计，因为如果你要更改的超类，你必须知道子类的所有细节。
好处：
提高了可复用性
创建了逻辑上的"is a"关系，如 Dog is a animal
模块化代码
避免重复
回顾我们的学习任务条，上面的数据显示我们每次作业代码的增加量和学习的进度，感觉一学期下来，且不说实实在在掌握了多少，但也下了功夫在上面，看着每周自己读译的代码渐渐变多，内心有着充实感，在复习阶段也可以去翻翻以前的作业来加固知识。一学期快结束了，在老师和学长的帮助下，我们也对java这门课有了了解和掌握，希望以后也可以去自己学习这方面的知识，不要丢了忘了。最后，再次感谢我们的老师！（送花^-^）
201771010135 杨蓉庆《面对对象程序设计（java）》第十八周学习总结的更多相关文章
- 201771010134杨其菊《面向对象程序设计java》第八周学习总结
第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类: Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...
- 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结
<面向对象程序设计Java>第八周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...
- 201771010135杨蓉庆《面向对象程序设计（java）》第四周学习总结
学习目标 1.掌握类与对象的基础概念,理解类与对象的关系: 2.掌握对象与对象变量的关系: 3.掌握预定义类的基本使用方法,熟悉Math类.String类.math类.Scanner类.LocalDa ...
- 201771010134杨其菊《面向对象程序设计java》第七周学习总结
第七周学习总结 第一部分:理论知识 1.继承是面向对象程序设计(Object Oriented Programming-OOP)中软件重用的关键技术.继承机制使用已经定义的类作为基础建立新的类定义,新 ...
- 201771010128 王玉兰《面象对象程序设计 (Java) 》第六周学习总结
---恢复内容开始--- 第一部分:基础知识总结: 1.继承 A:用已有类来构建新类的一种机制,当定义了一个新类继承一个类时,这个新类就继承了这个类的方法和域以适应新的情况: B:特点:具有层次结构. ...
- 201771010118马昕璐《面向对象程序设计java》第八周学习总结
第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...
- 201771010135杨蓉庆 《面向对象程序设计（java）》第三周学习总结
一:第1-3章学习内容: 第一章:复习基本数据类型 整型 byte(1个字节 表示范围:-2^7 ~ (2^7)-1) short(2个字节 表示范围:-2^15~(2^15)-1) int(4个字节 ...
- 201771010135杨蓉庆《面向对象程序设计（java）》第六周学习总结
实验六 继承定义与使用 1.实验目的与要求 (1) 理解继承的定义: (2) 掌握子类的定义要求 (3) 掌握多态性的概念及用法: (4) 掌握抽象类的定义及用途: (5) 掌握类中4个成员访问权限修 ...
- 201771010135杨蓉庆《面向对象程序设计（java）》第二周学习总结
第一部分:理论知识学习部分 3.1 标识符:由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字,可用作:类名.变量名.方法名.数组名.文件名等.有Hello.$1234.程序名.www_12 ...
- 马凯军201771010116《面向对象程序设计Java》第八周学习总结
一,理论知识学习部分 6.1.1 接口概念 两种含义:一,Java接口,Java语言中存在的结构,有特定的语法和结构:二,一个类所具有的方法的特征集合,是一种逻辑上的抽象.前者叫做“Java接口”,后 ...
随机推荐
- C++——简单程序设计
1.一个简单的程序 #include <iostream> //iostream是头文件,用来说明要使用的对象的相关信息. using namespace std; //使用命名空间,解决 ...
- DoS攻击种类
DoS攻击有许多种类,主要有Land攻击.死亡之ping.泪滴.Smurf攻击及SYN洪水等. 据统计,在所有黑客攻击事件中,syn洪水攻击是最常见又最容易被利用的一种DoS攻击手法. 1.攻击原理 ...
- 【模板】裸SPFA
SPFA可以处理带负边权的图,可以判负环,然而SPFA容易被卡,即使加了各种优化. 队列优化的贝尔福德曼:裸SPFA //SPFA #include<bits/stdc++.h> usin ...
- js处理json字符串
后台输出的字符串为 res= {"result":"true","data":"提交成功"} 前台js无法转化成对象,需 ...
- 九、c++容器
9.1 简介 容器库是类模板与算法的汇集,允许程序员简单地访问常见数据结构,例如队列.链表和栈. 有三类容器--顺序容器.关联容器和无序关联容器--每种都被设计为支持不同组的操作. 顺序容器:顺序容器 ...
- 2020年国外PhD申请QQ群907928541
2020年申请国外读博的 可以加QQ群:907928541 供大家学习交流套磁!
- [人物存档]【AI少女】【捏脸数据】人物鉴赏190
AISChaF_20200201011129905.png AISChaF_20200123004135233.png
- 后端工具——Maven——初篇——目录
目录 Maven的知识体系包括四个部分.Maven的配置文件,Maven命令,Maven生命周期,Maven插件.在介绍Maven之前,首先需要介绍如何安装Maven. 安装:介绍Maven在Linu ...
- EAC3 spectral extension原理
1.Spectral extension简介 Spectral extension是通过低频的transform coefficients合成高频transform coefficients的过程. ...
- IntelliJ IDEA 2017.3尚硅谷-----查看项目配置