Java实验报告2021
2021Java程序设计实验报告-hitwh
·
仅供参考，不要抄袭
实验一 Java结构化程序设计
一、 实验目的
(1) 熟悉和理解Java中的数据类型、运算符、表达式、程序结构等内容。
(2) 掌握常用的输入输出方法，编写、调试简单的程序。
(3) 掌握选择、循环等语句用法。
(4) 学会使用Java提供的类及方法。
(5) 熟练绘制程序流程图。
二、 实验内容
(1) 计算1/1+1/3+1/5+…+的前n项值并在控制台中输出，例如，n=4，计算1/1+1/3+1/5+1/7的值。
(2) 输入两个正整数m和n，求出它们的最小公倍数和最大公约数并在控制台中输出。
(3) 求出所有的水仙数并在控制台中输出，水仙数是三位数，它的各位数字的立方和等于这个数本身，例如，371=3*3*3+7*7*7+1*1*1。
(4) 输入正整数n，求出从1到n的所有完全数并在控制台中输出，所谓完全数是指一个数，该数恰好等于它的因子之和，例如，6是一个完全数，因为6的因子为1、2和3，而6=1+2+3。
(5) 输入正整数n，求出1到n之间的所有素数，在控制台中输出这些素数。
(6) 随机生成的1000个1至100以内的整数，统计每个整数出现的次数。
(7) 随机生成区间[min, max]内n(n>1)个不重复的整数，其中，min和max为非负整数，min<max，max-min+1≥n。
(8) 设计一个矩阵乘法程序，输入两个矩阵可以计算出它们的乘积。
import java.util.Random;
import java.util.Scanner;
public class Lab {
//(1)求1/n的前N项和
public static void Sum() {
Scanner in = new Scanner(System.in);
double sum = 0;
int n = in.nextInt();
if(n < 1) {
System.out.println("输入不合法.");
System.exit(-1);
}
for(int i = 1; i <= n; i++)
sum += 1.0 / (2*i-1);
System.out.println("sum = " + sum);
}
//(2)求两个数得到最大公约数和最小公倍数
public static void GCD_LCM() {
Scanner in = new Scanner(System.in);
int m = in.nextInt();
int n = in.nextInt();
if(m < 0 || n < 0) {
System.out.println("输入不合法.");
System.exit(-1);
}
if(m == 0 || n == 0)
System.out.println("GCD = 0, LCM = 0");
else {
int i;
int min = Math.min(m, n);
for (i = min; i > 0; --i)
if (m % i == 0 && n % i == 0)
break;
System.out.println("GCD = "+i+", LCM = "+(m/i*n));
}
}
//(3)输出水仙花数
public static void NarcissisticNumber() {
int a, b, c;
for(int i = 100; i < 1000; i++) {
a = i % 10; //个位
b = (i / 10) % 10; //十位
c = i / 100; //百位
if((int)Math.pow(a,3)+(int)Math.pow(b,3)+(int)Math.pow(c,3) == i)
System.out.println(i);
}
}
//(4)输入正整数n，求出从1到n的所有完全数并在控制台中输出
public static void PerfectNumber() {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
if(n < 1) {
System.out.println("输入不合法.");
System.exit(-1);
}
for(int i = 1; i <= n; i++){
int sum = 1;
for(int j = 2; j < i; j++) //求i所有因子的和，但不包括自身
if(n % j == 0)
sum += j;
if(i == sum)
System.out.println(i);
}
}
//(5)输入正整数n，求出1到n之间的所有素数，在控制台中输出这些素数
//判断n是否是素数,是素数则返回true,否则返回false
public static boolean isPrime(int n) {
if(n < 2) return false;
for(int i = 2; i < n; i++)
if(n % i == 0)
return false;
return true;
}
public static void PrimeNumber() {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
if(n < 1) {
System.out.println("输入不合法.");
System.exit(-1);
}
for(int i = 2; i < n; i++)
if(isPrime(i))
System.out.print(i + " ");
}
//(6)随机生成的1000个1至100以内的整数，统计每个整数出现的次数
public static void Random_Times() {
int[] times = new int[101];
for(int i = 0; i < 1000; i++)
++times[(int)(Math.random()*100+1)];
for(int i = 1; i < 101; i++)
System.out.println(i + "出现了" + times[i] + "次.");
}
// (7) 随机生成区间[min, max]内n(n>=1)个不重复的整数
// 其中，min和max为非负整数，min<max，max-min+1>=n。
public static void RandomInterval() {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
if(n < 1) {
System.out.println("n输入不合法.");
System.exit(-1);
}
int min = in.nextInt();
if(min < 0) {
System.out.println("min输入不合法.");
System.exit(-1);
}
int max = in.nextInt();
if(max < 0 || max <= min || max-min+1 < n) {
System.out.println("max输入不合法.");
System.exit(-1);
}
int length = max - min + 1; //闭区间长度
Random random = new Random(); //创建随机类对象
int[] array = new int[n]; //存放n个不重复整数的数组
for(int i = 0; i < n; i++) {
array[i] = random.nextInt(length)+min;
//生成[min, max+1)区间的随机数存放在数组中
// 检查重复的随机数
// 时间复杂度需要改善，想法如下:设置一个bool类的开关，一个int类型的temp记录值,避免重复的检查
for(int j = 0; j < i; j++) {
if(array[i] == array[j]) {
i--;
break;
}
}
}
for(int i : array)
System.out.print(i + " ");
}
//(8)矩阵乘法
public static void MatrixMultiple(int rA, int cA, int rB, int cB) {
Scanner in = new Scanner(System.in);
int[][] dataA = new int[rA][cA];
for (int i = 0; i < rA; i++)
for (int j = 0; j < cA; j++)
dataA[i][j] = in.nextInt();
int[][] dataB = new int[rB][cB];
for (int i = 0; i < rB; i++)
for (int j = 0; j < cB; j++)
dataB[i][j] = in.nextInt();
if (cA != rB && cB != rA) {
System.out.println("矩阵A、B不能进行乘法计算.");
} else {
int[][] dataC;
if (cA != rB && cB == rA) { //执行B * A = C
System.out.println("矩阵A不能右乘矩阵B，下面输出A左乘B的结果:");
dataC = new int[rB][cA];
for (int i = 0; i < rB; i++)
for (int j = 0; j < cA; j++)
for (int k = 0; k < rA; k++)
dataC[i][j] += dataB[i][k] * dataA[k][i];
for (int i = 0; i < rB; i++) {
for (int j = 0; j < cA; j++)
System.out.print(dataC[i][j] + " ");
System.out.println();
}
} else {
System.out.println("矩阵A右乘矩阵B结果如下:");
dataC = new int[rA][cB];
for (int i = 0; i < rA; i++)
for (int j = 0; j < cB; j++)
for (int k = 0; k < rB; k++)
dataC[i][j] += dataA[i][k] * dataB[k][j];
//输出
for (int i = 0; i < rA; i++) {
for (int j = 0; j < cB; j++)
System.out.print(dataC[i][j] + " ");
System.out.println();
}
}
}
}
public static void main(String[] args) {
Sum();
GCD_LCM();
NarcissisticNumber();
PerfectNumber();
PrimeNumber();
Random_Times();
RandomInterval();
MatrixMultiple(2,2,2,3);
}
}
实验二 Java面向对象程序设计
一、 实验目的
(1) 熟悉和理解Java中的类、方法等概念，掌握类的定义和使用，能够在程序中定义自己使用的类，编写构造方法及成员方法。
(2) 能够创建类的实例，掌握对象的声明和不同访问属性的成员访问方式，正确调用类的方法。
(3) 深入理解Java中的继承概念，掌握继承的使用方法。
二、 实验内容
2.1 Pay类
(1) 创建一个名为pay的类，该类包括每小时价格(price)、扣缴率(withhold_rate)、工资率(pay_rate)和应得工资 (payment) 等4个double型成员变量。创建3个重载方法computePayment()来计算应得工资，计算规则如下：
- 当computePayment()接收小时、扣缴率和工资率三个参数值时，计算应得工资=工作小时*每小时工资*(1-扣缴率)*(1-工资率)；
- 当computePayment()接收小时和工资率两个参数时，扣缴率为15%，计算应得工资=工作小时*每小时工资*(1-0.15)*(1-工资率)；
- 当computePayment()接收一个参数时，扣缴率为15%，每小时工资率为4.65%，计算应得工资=工作小时*每小时工资*(1-0.15)*(1-0.0465)。
编写一个测试类Test，该测试类的main方法测试所有3个重载的方法。
public class Test {
public static void main(String[] args) {
Pay p = new Pay(7);
p.computePayment(3);
p.printPayment();
p.computePayment(3, 0.0465);
p.printPayment();
p.computePayment(3, 0.15, 0.0465);
p.printPayment();
}
}
class Pay {
double price; //每小时价格
double withhold_rate; //扣缴率
double pay_rate; //工资率
double payment; //应得工资
Pay(double price) {
this.price = price;
}
void printPayment() {
System.out.println("Payment = " + payment);
}
void computePayment(double hours, double wr, double pr) {
this.withhold_rate = wr;
this.pay_rate = pr;
payment = hours * price * (1 - wr) * (1 - pr);
}
void computePayment(double hours, double pr) {
this.pay_rate = pr;
payment = hours * price * (1 - 0.15) * (1 - pr);
}
void computePayment(double hours) {
payment = hours * price * (1 - 0.15) * (1 - 0.0465);
}
}
2.2 图形类
(2) 编写一个Java应用程序，该程序中有三个类：Triangle、Trapezoid和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。具体要求如下：
- Triangle类具有类型为double的三个边，以及周长、面积属性，Triangle类具有返回周长、面积以及修改三个边的功能。此外，Triangle类还有一个boolean型的属性，该属性用来判断三个数能够构成一个三角形。完成上述操作后，给Triangle再增加3个方法，分别用来返回3个边sideA, sideB, sideC的值。
- Lander类具有类型为double的上底、下底、高、面积属性，具有返回面积的功能。
- Circle类具有类型为double的半径、周长和面积属性，具有返回周长、面积的功能。
- 编写一个测试类Test，分别创建类Triangle、Trapezoid和Circle的对象，并计算三角形、梯形和圆形的周长和面积。
public class Test {
public static void main(String[] args) {
Triangle a = new Triangle(3, 4, 5);
System.out.println("三角形周长 = "+a.getPerimeter()+", 面积 = "+a.getArea());
Lander b = new Lander(3, 4, 5);
System.out.println("梯形面积 = "+ b.getArea());
Circle c = new Circle(10);
System.out.println("圆周长 = " + c.getCircumference() + ", 面积 = " + c.getArea());
}
}
class Triangle {
double side1, side2, side3;
boolean check;
Triangle(double a, double b, double c) {
this.side1 = a;
this.side2 = b;
this.side3 = c;
Check();
}
private void Check() {
if (side1 < side2) {
double temp = side1;
side1 = side2;
side2 = temp;
} // 确保side1 - side2 > 0
check = side1 + side2 > side3 && side1 - side2 < side3;
}
double getPerimeter() {
return check ? side1 + side2 + side3 : 0;
}
double getArea() {
return check ?
(1.0 / 4 * Math.sqrt((side1 + side2 + side3) * (side1 + side2 - side3) * (side1 + side3 - side2) * (side2 + side3 - side1)))
: 0; //Heron公式
}
void setSide1(double side) {
this.side1 = side;
Check();
}
void setSide2(double side) {
this.side1 = side;
Check();
}
void setSide3(double side) {
this.side1 = side;
Check();
}
}
class Lander {
double upperBase, bottom, high, area;
Lander(double up, double bottom, double high) {
this.upperBase = up;
this.bottom = bottom;
this.high = high;
}
double getArea() {
return (upperBase + bottom) / 2 * high;
}
}
class Circle {
double radius, circumference, area;
Circle(double r) {
this.radius = r;
}
double getCircumference() {
return 2 * Math.PI * radius;
}
double getArea() {
return Math.PI * radius * radius;
}
}
2.3 学生成绩管理程序
(3) 编写一个一个简单的学生成绩管理程序，该程序中有三个类：学生(Student)、课程(Course)和成绩(Grade)，学生类的属性主要有姓名、学号、性别和班级，课程类属性主要有课程号、课程名和学分，成绩类的主要属性有学生姓名、课程名和课程成绩。要求：
- 学生、课程和成绩信息分别存储在一个List容器中。
- 程序的主要能包括：计算每个学生的总成绩、平均成绩和总学分，计算每个班级的平均成绩，按照学生平均成绩由高到低的顺序进行排序，统计所有学生每门课程的平均成绩。
- 设计一个数据集来测试上述功能的正确性。
import java.util.*;
enum Sex { 男, 女 }
public class Test {
public static void main(String[] args) {
Student.addStudent(); //添加数据集
Grade.addGrade();
Course.addCourse();
Student.setStuAll(Grade.gList, Course.cList); //计算每个学生的总成绩、平均成绩和总学分
Student.PrintStudent();
Course.getAverageGrade(Grade.gList); //统计所有学生每门课程的平均成绩
Course.PrintCourse();
Student.rankStudent(); //求排名
Grade.ClassGrade(); //求班级平均成绩
}
}
/* 编写一个一个简单的学生成绩管理程序，该程序中有三个类：学生(Student)、课程(Course)和成绩(Grade)，
学生类的属性主要有姓名、学号、性别和班级，课程类属性主要有课程号、课程名和学分，成绩类的主要属性有学生姓名、课程名和课程成绩
1) 学生、课程和成绩信息分别存储在一个List容器中 OK
2) 计算每个学生的总成绩、平均成绩和总学分，统计所有学生每门课程的平均成绩 OK
3) 计算每个班级的平均成绩，按照学生平均成绩由高到低的顺序进行排序 OK */
class Student {
String name;
String ID;
Sex sex;
String Class;
public static Collection<Student> stuList = new ArrayList();
double grade, averGrade, allCredit;
public String getName() { return name; }
public double getGrade() { return grade; }
public String getStuClass() { return Class; }
Student(String name, double grade) {
this.name = name;
this.grade = grade;
}
Student(String name, String ID, Sex sex, String Class) {
this.name = name;
this.ID = ID;
this.sex = sex;
this.Class = Class;
grade = averGrade = allCredit = 0.0;
}
public static void addStudent() {
stuList.add(new Student("赵一", "20111011", Sex.男, "2011101"));
stuList.add(new Student("钱二", "20111012", Sex.男, "2011101"));
stuList.add(new Student("孙三", "20111013", Sex.女, "2011101"));
stuList.add(new Student("李四", "20111021", Sex.男, "2011102"));
stuList.add(new Student("周五", "20111022", Sex.男, "2011102"));
stuList.add(new Student("吴六", "20111023", Sex.女, "2011102"));
}
public static void PrintStudent() {
System.out.println("姓名 学号 性别 班级 总成绩 平均成绩 总学分");
for (Student stu : stuList) {
System.out.print(stu.name + " " + stu.ID + " " + stu.sex.toString() + " " + stu.Class + " ");
System.out.println(stu.grade + " " + String.format("%.2f",stu.averGrade) + " " + stu.allCredit);
}
}
public static void setStuAll(Collection<Grade> gList, Collection<Course> cList) {
// 计算学生的总成绩、平均成绩和总分
int count; //选课个数
for(Student stu : stuList) { //处理学生清单中每一个学生
count = 0;
for(Grade g : gList) { //在成绩清单中找该学生的成绩
if(g.studentName.equals(stu.name)) {
stu.grade += g.CourseGrade; //计算总成绩
count++; //选课个数加一
if(g.CourseGrade >= 60) { //成绩及格，则累加学分
for (Course c : cList) //在课程清单找对应课程的学分
if (c.name.equals(g.CourseName))
stu.allCredit += c.credit; //计算总学分
}
}
}
stu.averGrade = stu.grade / count; //根据总成绩计算平均成绩
}
}
public static void rankStudent() {
List<Student> rank = new ArrayList<>();
for(Student s : stuList) {
rank.add(new Student(s.getName(), s.averGrade));
}
rank.sort(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getGrade() < o2.getGrade() ? 1 : -1;
}
});
System.out.println("\n学生排名如下:");
int i = 0;
for(Student s : rank)
System.out.println("\tName："+s.getName()+", Rank:" + (++i));
}
}
class Course {
String number;
String name;
double credit; //学分
public static Collection<Course> cList = new ArrayList();
double averCourseGrade;
public static void addCourse() {
// 初始化课程表
cList.add(new Course("SE33021", " Java ", 2.5));
cList.add(new Course("SE32005", "数字电路", 3.0));
cList.add(new Course("SE32007", "数据结构", 3.5));
}
Course(String number, String name, double credit) {
this.number = number;
this.name = name;
this.credit = credit;
averCourseGrade = 0;
}
public static void PrintCourse() {
System.out.println("\n课程号 课程名 学分 平均成绩");
for(Course c : cList) {
System.out.println(c.number+" "+c.name+" "+c.credit+" "+String.format("%.2f",c.averCourseGrade));
}
}
public static void getAverageGrade(Collection<Grade> gList) {
int count;
for(Course c : cList) {
count = 0;
for(Grade g : gList) {
if(g.CourseName.equals(c.name)){
c.averCourseGrade += g.CourseGrade;
count++;
}
}
if(count != 0) c.averCourseGrade /= count;
}
}
}
class Grade {
String studentName;
String CourseName;
double CourseGrade;
public static Collection<Grade> gList = new ArrayList();
public static void addGrade() {
gList.add(new Grade("赵一", " Java ", 99));
gList.add(new Grade("赵一", "数字电路", 89));
gList.add(new Grade("赵一", "数据结构", 79));
gList.add(new Grade("钱二", " Java ", 88));
gList.add(new Grade("钱二", "数字电路", 78));
gList.add(new Grade("钱二", "数据结构", 68));
gList.add(new Grade("孙三", " Java ", 77));
gList.add(new Grade("孙三", "数字电路", 67));
gList.add(new Grade("孙三", "数据结构", 57));
gList.add(new Grade("李四", " Java ", 66));
gList.add(new Grade("李四", "数字电路", 76));
gList.add(new Grade("李四", "数据结构", 76));
gList.add(new Grade("周五", " Java ", 55));
gList.add(new Grade("周五", "数字电路", 65));
gList.add(new Grade("周五", "数据结构", 75));
gList.add(new Grade("吴六", " Java ", 100));
gList.add(new Grade("吴六", "数字电路", 100));
gList.add(new Grade("吴六", "数据结构", 100));
}
Grade(String sName, String cName, double cGrade) {
this.studentName = sName;
this.CourseName = cName;
this.CourseGrade = cGrade;
}
public static void ClassGrade() {
Map<String, Integer> totalGrade = new HashMap<>();
Map<String, Integer> total = new HashMap<>();
Map<String, String> cName = new HashMap<>();
Set<String> classes = new HashSet<>();
for(Student s : Student.stuList) {
total.put(s.getStuClass(), 0);
totalGrade.put(s.getStuClass(), 0);
cName.put(s.getName(), s.getStuClass());
classes.add(s.getStuClass());
}
for(Grade grade : gList) {
totalGrade.put(cName.get(grade.studentName), totalGrade.get(cName.get(grade.studentName)) + (int)grade.CourseGrade);
total.put(cName.get(grade.studentName), total.get(cName.get(grade.studentName))+1);
}
System.out.println("\n班级平均成绩如下：");
for(String name : classes)
System.out.println("班级:"+name+", 平均分:"+ String.format("%.2f",1.0 * totalGrade.get(name) / total.get(name)));
}
}
实验三 Java综合设计
一、 实验目的
(1) 掌握集合的使用方法，如插入、删除和查找等功能。
(2) 理解Java图形用户界面设计中的事件处理模型。
(3) 理解Java数据流和多线程概念及应用。
(4) 掌握Java的网络编程方法，理解针对网络通信的不通层次(应用层、传输层和网络层)，Java所能提供的网络功能及方法。
二、 实验内容
3.1 图书管理系统
(1) 设计一个简单的图书管理系统，该系统使用集合保存图书信息，包括书名、作者、出版社、刊号、出版日期、页数和摘要，并能够实现图书的插入、删除、查找功能。插入、删除时要显示操作是否正确与否的提示信息；查找时按关键字值进行查找，并显示查找结果。
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
/*设计一个简单的图书管理系统，该系统使用集合保存图书信息，
* 包括书名、作者、出版社、刊号、出版日期、页数和摘要，实现图书的插入、删除、查找功能。
* 插入、删除时要显示操作是否正确与否的提示信息；查找时按关键字值进行查找，并显示查找结果 */
public class BookManager {
JFrame frame;
JButton btnAdd, btnDelete, btnSearch, btnPrint; //选项按钮: 图书的插入、删除、查找、显示
JPanel buttonsPanel, //选项按钮的面板容器 放置选项按钮
textPanel, //文本域的面板容器 放置文本域
inputPanel; //输入的面板容器
JPanel panelName, panelAuthor, panelPress, panelNumber, //书名、作者、出版社、刊号
panelDate, panelPages, panelAbstract; //出版日期、页数和摘要
JTextArea outputTextArea; //输出文本域
JTextField txtName, txtAuthor, txtPress, txtNumber,
txtDate, txtPages, txtAbstract; //文本域 输入对应信息
JScrollPane scrollPane; //滚动条
Container contentPane;
private List<Book> books = new ArrayList<>();
//构造器
public BookManager() { //初始化
frame = new JFrame("图书管理系统");
panelName = new JPanel();
panelAuthor = new JPanel();
panelPress = new JPanel();
panelNumber = new JPanel();
panelDate = new JPanel();
panelPages = new JPanel();
panelAbstract = new JPanel();
txtName = new JTextField();
txtAuthor = new JTextField();
txtPress = new JTextField();
txtNumber = new JTextField();
txtDate = new JTextField();
txtPages = new JTextField();
txtAbstract = new JTextField();
Border etched = BorderFactory.createEtchedBorder();
Border buttonBorder = BorderFactory.createTitledBorder(etched,"功能选项");
Border inputBorder = BorderFactory.createTitledBorder(etched,"信息填写");
Border outputBorder = BorderFactory.createTitledBorder(etched,"信息显示");
textPanel = new JPanel();
textPanel.setLayout(new BoxLayout(textPanel, BoxLayout.X_AXIS));
initInputPanel(inputBorder);
initOutputPanel(outputBorder);
initButtonPanel(buttonBorder);
onClickListener();
contentPane = frame.getContentPane();
contentPane.setLayout(new BorderLayout());
contentPane.add(textPanel,BorderLayout.CENTER);
contentPane.add(buttonsPanel,BorderLayout.SOUTH);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//frame.pack();
frame.setSize(1000, 400);
frame.setVisible(true);//可见
}
//按钮事件监听器
public void onClickListener() {
//添加图书信息
btnAdd.addActionListener(e -> {
if (txtName.getText().equals("") || txtNumber.getText().equals("") ||
txtAuthor.getText().equals("") || txtPress.getText().equals("") ||
txtPages.getText().equals("") || txtDate.getText().equals("") ||
txtAbstract.getText().equals("") ) { //如果缺少图书信息，则弹出错误提示窗口
JOptionPane.showMessageDialog(frame,"图书信息填写不完整","错误", JOptionPane.ERROR_MESSAGE);
} else { //信息齐全则添加该书
Book book = new Book();
book.setName(txtName.getText());
book.setAuthor(txtAuthor.getText());
book.setPress(txtPress.getText());
book.setNumber(txtNumber.getText());
book.setDate(txtDate.getText());
book.setPages(txtPages.getText());
book.setAbs(txtAbstract.getText());
books.add(book); //将新书籍添加进集合
JOptionPane.showMessageDialog(frame,"图书信息添加成功","成功", JOptionPane.PLAIN_MESSAGE);
}
//清空输入文本域
txtName.setText("");
txtAuthor.setText("");
txtPress.setText("");
txtNumber.setText("");
txtDate.setText("");
txtPages.setText("");
txtAbstract.setText("");
});
//删除图书信息
btnDelete.addActionListener((ActionListener) e -> {
outputTextArea.setText("");
if(txtName.getText().equals("")) { //关键词为空
JOptionPane.showMessageDialog(frame,"待删除书名为空","错误", JOptionPane.ERROR_MESSAGE);
} else {
String bName = txtName.getText();
boolean isDelete = false; //是否找到待删除的书
for(Book b : books) {
if(b.getName().equals(bName)) { //找到书
isDelete = true;
outputTextArea.append("已删除书籍：\n" + "书名:" + b.getName() + ", 作者:" + b.getAuthor() +
", 出版社:" + b.getPress() + ", 期刊号:" + b.getNumber() + ", 出版日期:" + b.getDate() +
", 页数:" + b.getPages() + "\n" + " 摘要：" + b.getAbs() + "\n");
books.remove(b); //从集合中删去该书
JOptionPane.showMessageDialog(frame,"图书删除成功","成功", JOptionPane.PLAIN_MESSAGE);
break;
}
}
if(!isDelete) { //在集合中未找到相关的书
JOptionPane.showMessageDialog(frame,"未找到相关图书","错误", JOptionPane.ERROR_MESSAGE);
}
}
});
//查找图书
btnSearch.addActionListener((ActionListener) e -> {
outputTextArea.setText("");
if(txtName.getText().equals("")) { //关键词为空
JOptionPane.showMessageDialog(frame,"未输入书名关键词","错误", JOptionPane.ERROR_MESSAGE);
} else {
String name = txtName.getText();
boolean isFound = false; //是否找到书
outputTextArea.append("包含关键词 \""+name+"\" 的书：\n");
for(Book b : books) {
if(b.getName().contains(name)) { //找到书
isFound = true;
outputTextArea.append("书名:《" + b.getName()+
"》, 作者: "+b.getAuthor()+", 出版社: "+b.getPress()+", 期刊号: "+b.getNumber()
+", 出版日期: "+b.getDate()+", 页数: "+b.getPages()+"\n" +
"\t 摘要："+b.getAbs() + "\n");
//break; //相关图书可能不止一本
}
}
if(!isFound) { //在集合中未找到相关的书
JOptionPane.showMessageDialog(frame,"未找到相关图书","错误", JOptionPane.ERROR_MESSAGE);
}
}
});
//显示全部图书信息
btnPrint.addActionListener((ActionListener) e -> {
outputTextArea.setText("");
for(Book b : books) {
outputTextArea.append("书名:《"+b.getName()+"》, 作者:"+b.getAuthor()+", 出版社:"+b.getPress()+
", 期刊号:"+b.getNumber()+", 出版日期:"+b.getDate()+", 页数:"+b.getPages()+"\n"+
"\t 摘要：" + b.getAbs() +"\n");
}
});
}
//初始化输入组件
public void initInputPanel(Border border) {
inputPanel = new JPanel();
inputPanel.setLayout(new GridLayout(4,2,10,20)); //网格模式
initInputTextField(panelName,"书名：", txtName);
initInputTextField(panelAuthor,"作者：", txtAuthor);
initInputTextField(panelPress, "出版社：", txtPress);
initInputTextField(panelNumber,"期刊号：", txtNumber);
initInputTextField(panelDate,"出版日期：", txtDate);
initInputTextField(panelPages,"页数：", txtPages);
initInputTextField(panelAbstract,"摘要：", txtAbstract);
inputPanel.setBorder(border);
textPanel.add(inputPanel,BorderLayout.CENTER);
}
//初始化输出组件（输出文本域）
public void initOutputPanel(Border border) {
outputTextArea = new JTextArea();
outputTextArea.setSize(1000, 300);
scrollPane = new JScrollPane(outputTextArea);
//需要时出现 垂直/水平滚动条
scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
scrollPane.setBorder(border);
textPanel.add(scrollPane);
}
//初始化按钮组件
public void initButtonPanel(Border border){
buttonsPanel = new JPanel();
buttonsPanel.setLayout(new FlowLayout(FlowLayout.CENTER,40,20));
buttonsPanel.setBorder(border);
btnAdd = new JButton("添加书籍");
btnDelete = new JButton("删除书籍");
btnSearch = new JButton("查找书籍");
btnPrint = new JButton("显示全部书籍");
buttonsPanel.add(btnAdd);
buttonsPanel.add(btnDelete);
buttonsPanel.add(btnSearch);
buttonsPanel.add(btnPrint);
}
//初始化输入文本域
public void initInputTextField(JPanel panel, String str, JTextField textField){
textField.setPreferredSize(new Dimension(60,5));
panel.setLayout(new BoxLayout(panel,BoxLayout.X_AXIS));
panel.add(new JLabel(str,JLabel.CENTER),BorderLayout.WEST);
panel.add(textField,BorderLayout.EAST);
panel.setPreferredSize(new Dimension(100,30));
inputPanel.add(panel);
}
public static void main(String[] args) {
BookManager bm = new BookManager();
}
}
// 书籍类: 书名、作者、出版社、刊号、出版日期、页数和摘要
class Book {
private String name; //书名
private String author; //作者
private String press; //出版社
private String number; //期刊号
private String date; //出版日期
private String pages; //页数
private String abs; //摘要
//setter方法
public void setName(String name) { this.name = name; }
public void setAuthor(String author) { this.author = author; }
public void setPress(String press) { this.press = press; }
public void setNumber(String number) { this.number = number; }
public void setDate(String date) { this.date = date; }
public void setPages(String pages) { this.pages = pages; }
public void setAbs(String abs) { this.abs = abs; }
//getter方法
public String getName() { return name; }
public String getAuthor() { return author; }
public String getPress() { return press; }
public String getNumber() { return number; }
public String getDate() { return date; }
public String getPages() { return pages; }
public String getAbs() { return abs; }
}
3.2 赛马
(2) 编写一个多线程的控制程序，称为赛马程序。创建分别代表两匹马的两个线程，并将它们设置为高低不同的优先级，并以进度条的形式显示赛马过程
import javax.swing.*;
import java.awt.*;
public class race {
JFrame f; //窗口对象
JPanel p; //面板容器对象
JLabel l1, l2; //标签组件对象
static JProgressBar pb1, pb2; //进度条组件对象
static Thread thread1, thread2; //线程对象
void go() {
f = new JFrame("赛马程序");
p = new JPanel();
p.setLayout(new GridLayout(2, 2)); //2x2网格布局
l1 = new JLabel("小马宝莉");
l2 = new JLabel("老马保国");
//设置水平方向的进度条,最小值0,最大值100
pb1 = new JProgressBar(SwingConstants.HORIZONTAL, 0, 100);
pb2 = new JProgressBar(SwingConstants.HORIZONTAL, 0, 100);
p.add(l1); p.add(pb1); p.add(l2); p.add(pb2); //面板添加组件
f.getContentPane().add(p, BorderLayout.CENTER); //在窗口中间放置面板
f.setSize(300, 70); //窗口大小300x70
f.setVisible(true); //窗口可见
f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //关闭窗口则进程结束
}
public static void main(String[] args) {
race r = new race();
r.go();
thread1 = new Thread1();
thread2 = new Thread2();
thread1.setPriority(4); //设置线程1的优先级
thread2.setPriority(6); //设置线程2的优先级
thread1.start();
thread2.start();
}
}
class Thread1 extends Thread {
public void run() {
while (race.pb1.getValue() < 100 && race.pb2.getValue() < 100) {
race.pb1.setValue(race.pb1.getValue()+(int)(Math.random()*2));
try {
Thread.sleep((int)(Math.random()*50));
} catch (InterruptedException e) {
e.printStackTrace();
}
//比赛评比规则
if(race.pb1.getValue() == 100 && race.pb2.getValue() != 100) {
JOptionPane.showMessageDialog(null,"马老大胜利！"); //弹出信息框
break;
}
else if(race.pb2.getValue() == 100 && race.pb1.getValue() != 100) {
JOptionPane.showMessageDialog(null,"马老二胜利！");
break;
}
else if(race.pb1.getValue() == 100 && race.pb2.getValue() == 100) {
JOptionPane.showMessageDialog(null,"平局qwq");
break;
}
}
}
}
class Thread2 extends Thread {
public void run() {
while (race.pb2.getValue() < 100) {
race.pb2.setValue(race.pb2.getValue()+(int)(Math.random()*2));
try {
Thread.sleep((int)(Math.random()*50));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3.3 文件上传与下载系统
(3) 编写一个简单的文件上传和下载系统，该系统包含两个应用程序：客户端应用程序和服务器端应用程序，客户端应用程序与服务器端应用程序建立连接，可以从服务器端下载文件，同时能够上传文件到服务器端
import java.io.*;
import java.net.Socket;
import java.net.*;
import java.util.Scanner;
public class Upload {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8080);
Socket socket = serverSocket.accept();
InputStream is = socket.getInputStream();
Scanner in = new Scanner(System.in);
System.out.print("Path:");
String outputPath = in.nextLine();;
FileOutputStream fos = new FileOutputStream(new File(outputPath));
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
System.out.println("success！The output path is:" + outputPath);
fos.close();
is.close();
socket.close();
serverSocket.close();
}
}
import java.io.*;
import java.net.Socket;
import java.net.*;
import java.util.Scanner;
public class Download {
public static void main(String[] args) throws Exception {
Socket socket = new Socket(InetAddress.getLocalHost(), 8080);
OutputStream os = socket.getOutputStream();
Scanner in = new Scanner(System.in);
System.out.print("please input the path:");
String path = in.nextLine();
FileInputStream fis = new FileInputStream(new File(path));
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
fis.close();
os.close();
socket.close();
}
}
为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。
更多推荐
21
0- 0
已为社区贡献1条内容
所有评论(0)