JAVA第二次平时作业
作者：互联网
作业2：
作业要求：
设计一个处理复数运算的类，该类中至少有两个成员方法：
复数加法和复数减法运算。
在上述类中添加两个静态方法：求一个复数的模和求一个复
数的复角。
设计一个子类，该子类继承了上述的类，并且至少拥有自己
的两个方法：复数乘法和复数除法。
再设计一个类，包含main方法，对上面的类进行应用与测试。
该作业要求编程并调试通过。对你设计的类要有详细的文字
说明（类所封装的内容，属性、方法的功能与含义等）
代码：
package homework2;
//Calculate类
public class Calculate extends Operation{
public Calculate(){}
//计算两复数相乘
public Complex multiple(Complex complex1,Complex complex2){
double ret_real = complex1.real*complex2.real - complex1.imaginary*complex2.imaginary;
double ret_imaginary = complex1.real*complex2.imaginary + complex1.imaginary*complex2.real;
Complex ret = new Complex(ret_real,ret_imaginary);
return ret;
}
//计算两复数相除
public Complex div(Complex complex1,Complex complex2) {
double real = (complex1.real*complex2.real + complex1.imaginary*complex2.imaginary)
/(complex2.real*complex2.real + complex2.imaginary*complex2.imaginary);
double imaginary = (complex1.imaginary*complex2.real - complex1.real*complex2.imaginary)
/(complex2.real*complex2.real + complex2.imaginary*complex2.imaginary);
Complex ret = new Complex(real,imaginary);
return ret;
}
}
1 package homework2;
2
3 //复数类
4 public class Complex {
5 //实部和虚部
6 double real,imaginary;
7
8
9 public Complex(){}
10 //构造方法
11 public Complex(double real,double imaginary){
12 this.real = real;
13 this.imaginary = imaginary;
14 }
15
16 //输出复数的实部和虚部
17 public void print() {
18 System.out.println(real + " " + imaginary);
19 }
20 }
1 package homework2;
2
3 import java.lang.Math;
4
5 //处理复数运算的类
6 public class Operation {
7
8 public Operation(){}
9
10 //复数加法
11 public Complex add(Complex complex1,Complex complex2){
12 Complex ret = new Complex(complex1.real + complex2.real,complex1.imaginary + complex2.imaginary);
13 return ret;
14 }
15
16 //复数减法
17 public Complex sub(Complex complex1,Complex complex2){
18 Complex ret = new Complex(complex1.real - complex2.real,complex1.imaginary - complex2.imaginary);
19 return ret;
20 }
21
22 //求一个复数的模
23 public static double abs(Complex complex){
24 return Math.sqrt(complex.real*complex.real + complex.imaginary*complex.imaginary);
25 }
26
27 //求一个复数的辐角
28 public static double arg(Complex complex){
29 return Math.atan2(complex.imaginary,complex.real);
30 }
31
32 }
1 package homework2;
2
3 import java.util.Scanner;
4
5 //Test类包含main方法，对其他三个类进行应用与测试
6 public class Test {
7 public static void main(String args[]) {
8 Complex complex1 = new Complex();//复数1
9 Complex complex2 = new Complex();//复数2
10
11 //使用Scanner读入两复数
12 Scanner reader = new Scanner(System.in);
13 //读入第一个复数
14 System.out.println("请输入第一个复数的实部和虚部：");
15 complex1.real = reader.nextDouble();//读入实部
16 complex1.imaginary = reader.nextDouble();//读入虚部
17 //读入第二个复数
18 System.out.println("请输入第二个复数的实部和虚部：");
19 complex2.real = reader.nextDouble();//读入实部
20 complex2.imaginary = reader.nextDouble();//读入虚部
21
22 //停止输入
23 reader.close();
24
25 //创建operate对象
26 Operation operate = new Operation();
27
28 //通过operate实现两复数相加
29 Complex addtion = operate.add(complex1, complex2);
30 //输出相加后的结果
31 System.out.println("两复数相加后实部和虚部分别为");
32 addtion.print();
33
34 //通过operate实现两复数相减
35 Complex sub = operate.sub(complex1, complex2);
36 //输出相减后的结果
37 System.out.println("两复数相减后实部和虚部分别为");
38 sub.print();
39
40 //输出第一个复数的模长
41 System.out.println("第一个复数的模长为："+Operation.abs(complex1));
42 //输出第一个复数的辐角
43 System.out.println("第一个复数的辐角为："+Operation.arg(complex1));
44
45 //创建calculte对象
46 Calculate calculate = new Calculate();
47
48 //通过calculate实现两复数相乘
49 Complex mul = calculate.multiple(complex1, complex2);
50 //输出相乘后的结果
51 System.out.println("两复数相乘后实部和虚部分别为");
52 mul.print();
53
54 //通过calculate实现两复数相除
55 Complex div = calculate.div(complex1, complex2);
56 //输出相除后的结果
57 System.out.println("两复数相除后实部和虚部分别为");
58 div.print();
59 }
60 }
运行结果：
作业3：
作业要求：
编写一个线段类 MyLine，要求如下:
主要属性有： x ，y ；类型为Point (查看API)
编写构造方法，如 MyLine(Point p1 , Point p2)
编写5个成员方法。如：
检查线段是否位于第一象限check()…
求线段的长度 length() …
判断两条直线是否相交(另一线段作为参数)。
编写一点到该线段（或延长线）的距离
其他方法。
注：编写方法时，考虑利用Point类的方法
编写测试程序
该作业要求编程并调试通过。对你设计的类要有详细的文字
说明（类所封装的内容，属性、方法的功能与含义等）
代码：
1 package homework3;
2
3 import java.awt.Point;
4 import java.math.*;
5 import java.util.Scanner;
6
7 class MyLine {
8 Point x,y;
9
10 public MyLine(){}//构造方法
11
12 //构造方法
13 public MyLine(Point p1,Point p2){
14 x = p1;
15 y = p2;
16 }
17
18 //检查线段是否位于第一象限
19 public boolean check() {
20 if (x.x > 0 && x.y > 0 && y.x > 0 && y.y > 0) return true;
21 else return false;
22 }
23
24 //求线段的长度
25 public double length() {
26 return Math.sqrt((x.y-x.x)*(x.y-x.x)+(y.y-y.x)*(y.y-y.x));
27 }
28
29 //判断两条线段是否相交
30 public boolean intersection(MyLine bLine) {
31 /*
32 *快速排斥：
33 *两个线段为对角线组成的矩形，如果这两个矩形没有重叠的部分，那么两条线段是不可能出现重叠的
34 */
35 if(!(Math.min(this.x.x,this.y.x)<=Math.max(bLine.x.x,bLine.y.x) &&
36 Math.min(bLine.x.y,bLine.y.y)<=Math.max(this.x.y,this.y.y)&&
37 Math.min(bLine.x.x,bLine.y.x)<=Math.max(this.x.x,this.y.x) &&
38 Math.min(this.x.y,this.y.y)<=Math.max(bLine.x.y,bLine.y.y)))
39 return false;
40 /*
41 *跨立实验：
42 *如果两条线段相交，那么必须跨立，就是以一条线段为标准，另一条线段的两端点一定在这条线段的两段
43 *也就是说a b两点在线段cd的两端，c d两点在线段ab的两端
44 */
45 double u,v,w,z;//分别记录两个向量
46 u=(bLine.x.x-this.x.x)*(this.y.y-this.x.y)-(this.y.x-this.x.x)*(bLine.x.y-this.x.y);
47 v=(bLine.y.x-this.x.x)*(this.y.y-this.x.y)-(this.y.x-this.x.x)*(bLine.y.y-this.x.y);
48 w=(this.x.x-bLine.x.x)*(bLine.y.y-bLine.x.y)-(bLine.y.x-bLine.x.x)*(this.x.y-bLine.x.y);
49 z=(this.y.x-bLine.x.x)*(bLine.y.y-bLine.x.y)-(bLine.y.x-bLine.x.x)*(this.y.y-bLine.x.y);
50 return (u*v<=0.00000001 && w*z<=0.00000001);
51 }
52
53 //一点到该线段（或延长线）的距离
54 public double distancePointToMyLine(Point aPoint) {
55 double A = x.y - y.y;
56 double B = y.x - x.x;
57 double C = x.x*y.y-x.y*y.x;
58 double dis = (Math.abs(A*aPoint.x+B*aPoint.y+C)/Math.sqrt(A*A+B*B));
59 return dis;
60 }
61
62 //判断点是否在线段所在直线上
63 public boolean pointOnMyLine(Point aPoint) {
64 return ((y.y-x.y)/(y.x-x.x) == (aPoint.y - x.y)/(aPoint.x-x.x));
65 }
66 }
67
68 public class Test{
69 public static void main(String args[]) {
70
71 Scanner reader = new Scanner(System.in);
72
73 //输入第一条线段的左端点的横纵坐标
74 Point ax = new Point();
75 System.out.println("请输入第一条线段的左端点的横纵坐标");
76 ax.x = reader.nextInt();
77 ax.y = reader.nextInt();
78
79 //第一条线段的右端点的横纵坐标
80 Point ay = new Point();
81 System.out.println("请输入第一条线段的右端点的横纵坐标");
82 ay.x = reader.nextInt();
83 ay.y = reader.nextInt();
84
85 MyLine aLine = new MyLine(ax,ay);
86
87 //输入第二条线段的左端点的横纵坐标
88 Point bx = new Point();
89 System.out.println("请输入第二条线段的左端点的横纵坐标");
90 bx.x = reader.nextInt();
91 bx.y = reader.nextInt();
92
93 //输入第一条线段的右端点的横纵坐标
94 Point by = new Point();
95 System.out.println("请输入第一条线段的右端点的横纵坐标");
96 by.x = reader.nextInt();
97 by.y = reader.nextInt();
98
99 MyLine bLine = new MyLine(bx,by);
100
101 //检查线段是否位于第一象限
102 if (aLine.check()){
103 System.out.println("aLine在第一象限");
104 }else System.out.println("aLine不在第一象限");
105
106 //求线段的长度
107 System.out.println("aLine的长度是："+aLine.length());
108
109 //判断两条线段是否相交
110 if (aLine.intersection(bLine)){
111 System.out.println("aLine和bLine相交");
112 }else System.out.println("aLine和bLine不相交");
113
114 //输入一个点的坐标，然后求该点到aLine的距离
115 Point point = new Point();
116 System.out.println("请输入点的横纵坐标：");
117 point.x = reader.nextInt();
118 point.y = reader.nextInt();
119 //一点到该线段（或延长线）的距离
120 System.out.println("点到aLine的距离为："+aLine.distancePointToMyLine(point));
121
122 //判断点是否在线段所在直线上
123 if(aLine.pointOnMyLine(point)){
124 System.out.println("点在线段所在直线上");
125 }else System.out.println("点不在线段所在直线上");
126 }
127 }
运行结果：
作业4：
作业要求：
编写一个book类：
两个属性：
String bname （书名） int price（定价）
注：本题中假定书名唯一，可作为书的标识。
一个构造方法： book(String p1,int p2)
两个成员方法：
String getName() 获取书名
int getPrice() 获取价格
编写一个BookCard类（借书卡）
三个属性：
int rno 读者号
String rname 读者名
book[] books 在借图书（最多10本）
一个构造方法：
BookCard(int p1,String p2,book[] p3)
八个成员方法：
int getRno() 取读者号
String getRname() 取读者名
int bnum() 统计在借图书数（已借了几本书）
boolean borrow(book b)
借书方法：参数为所借书之对象。返回值为true表示借书成功，
返回值为false表示借书不成功（如已借10本）。
boolean returnBook(String s)
还书方法：参数为所还书名。返回值为true表示还书成功，返
回值为false表示还书不成功（如没借此书）
void printBooks()
该方法输出在借书名清单，每行一个书名。
int expensive(int p)
该方法统计出在借图书中定价高于参数p的图书册数。
String[] search(String s)
本方法的参数是指定的一个关键词（如“计算机”）。本方法找出所有在借图书中书名包括该关键词的图书，并将找到的书以数组形式返回。
提示：
数组元素为空时其值表示为 null
自己在主程序中编写测试用例，要用到BookCard类的8个方法，
要测试方法的不同返回值。例：
public static void main(String args[]){
book b1 =new book("计算机文化基础",23);
book b2 = new book("数据库与计算机管理",32);
book b3 = new book(“Java面向对象程序设计",40);
book[] books={b1,b2,b3};
BookCard b = new BookCard (980001,"王山",books);
b.printBooks() ;
. . . . . .
该作业要求编程并调试通过。对你设计的类要有详细的文字
说明（类所封装的内容，属性、方法的功能与含义等）
代码：
package task4;
//Book类
public class Book {
String bname;
int price;
Book(){}
//构造方法
Book(String bname,int price) {
this.bname = bname;
this.price = price;
}
//获得名字
String getName() {
return bname;
}
//获得价格
int getPrice() {
return price;
}
}
1 package task4;
2
3 public class BookCard {
4 int rno;
5 String rname;
6 Book [] books = new Book [10];
7 BookCard(int p1,String p2,Book[] p3){
8 rno = p1;
9 rname = p2;
10 books = p3;
11 }
12
13 //取读者号
14 int getRno(){
15 return rno;
16 }
17
18 //取读者名
19 String getRname(){
20 return rname;
21 }
22
23 //统计在借图书数
24 int bnum(){
25 return books.length;
26 }
27
28 //借书
29 boolean borrow(Book b){
30 if (books.length == 10) return false;
31 else {
32 int len = books.length;
33 books[len-1] = b;
34 return true;
35 }
36 }
37
38 //还书
39 boolean returnBook(String s){
40 for (int i = 0;i < books.length;++i){
41 if (books[i] != null && books[i].bname == s){
42 int len = books.length;
43 books[i] = books[len-1];
44 books[len-1] = null;
45 return true;
46 }
47 }
48 return false;
49 }
50
51 //输出在借书名清单
52 void printBooks(){
53 for(int i = 0;i < books.length;++i) {
54 System.out.println(books[i].getName());
55 }
56 }
57
58 //统计出在借图书中定价高于参数p的图书册数
59 int expensive(int p){
60 int count = 0;
61 for(int i = 0;i < books.length;++i) {
62 if(books[i] != null && books[i].getPrice() > p) count++;
63 }
64 return count;
65 }
66
67 //找出所有在借图书中书名包括该关键词的图书
68 String[] search(String s){
69 String[] ret = new String[10];
70 int cnt = 0;
71 for(int i = 0;i < books.length;++i) {
72 if(books[i] != null && books[i].getName().indexOf(s) != -1) ret[cnt++] = books[i].getName();
73 }
74 return ret;
75 }
76
77
78 }
1 package task4;
2
3 public class Test {
4 public static void main(String args[]){
5 Book b1 =new Book("离散数学及其应用",23);
6 Book b2 = new Book("大学计算机基础",32);
7 Book b3 = new Book("Java面向对象程序设计",40);
8 Book b4 = new Book("C++程序设计", 65);
9 Book b5 = new Book("大学英语", 12);
10 Book[] books={b1,b2,b3,b4,b4,b5,b5,b4,b5};
11 BookCard b = new BookCard (216132,"马泽雄",books);
12
13 System.out.println("读者号:" + b.getRno() + " 读者名:" + b.getRname() + " 在借图书数目:" + b.bnum());
14 //输出已经借了的图书
15 System.out.println("在借图书有：");
16 b.printBooks();
17
18 //借书测试
19 if (b.borrow(b5)){
20 System.out.println(b5.bname+"借书成功!");
21 }else System.out.println(b5.bname+"借书失败！");
22
23 //借书测试
24 if (b.borrow(b5)){
25 System.out.println(b5.bname+"借书成功!");
26 }else System.out.println(b5.bname+"借书失败！");
27
28 //还书测试
29 if(b.returnBook("离散数学及其应用")) {
30 System.out.println("离散数学及其应用还书成功!");
31 }else System.out.println("离散数学及其应用还书失败！");
32
33 //还书测试
34 if(b.returnBook("离散数学及其应用")) {
35 System.out.println("离散数学及其应用还书成功!");
36 }else System.out.println("离散数学及其应用还书失败！");
37
38
39 //寻找定价高于33的书
40 System.out.println("定价高于33的书有:" + b.expensive(33) + "本");
41
42 //寻找书名中含C的书
43 System.out.println("书名内包含C的书有:");
44 String[] cout = b.search("C");
45 for(int i = 0;cout[i] != null;++i) {
46 System.out.println(cout[i]);
47 }
48
49 }
50 }
运行结果：
标签：real,JAVA,complex2,int,作业,Complex,books,第二次,imaginary 来源： https://www.cnblogs.com/mizersy/p/10347765.html