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

package homework2;

//复数类
public class Complex {
    //实部和虚部
    double real,imaginary;
    
    
    public Complex(){}
    //构造方法
    public Complex(double real,double imaginary){
        this.real = real;
        this.imaginary = imaginary;
    }
    
    //输出复数的实部和虚部
    public void print() {
        System.out.println(real + " " + imaginary);
    }
}

package homework2;

import java.lang.Math;

//处理复数运算的类
public class Operation {
    
    public Operation(){}
    
    //复数加法
    public Complex add(Complex complex1,Complex complex2){
        Complex ret = new Complex(complex1.real + complex2.real,complex1.imaginary + complex2.imaginary);
        return ret;
    }
    
    //复数减法
    public Complex sub(Complex complex1,Complex complex2){
        Complex ret = new Complex(complex1.real - complex2.real,complex1.imaginary - complex2.imaginary);
        return ret; 
    }
    
    //求一个复数的模
    public static double abs(Complex complex){
        return Math.sqrt(complex.real*complex.real + complex.imaginary*complex.imaginary);
    }
    
    //求一个复数的辐角
    public static double arg(Complex complex){
        return Math.atan2(complex.imaginary,complex.real);
    }
    
}

package homework2;

import java.util.Scanner;

//Test类包含main方法，对其他三个类进行应用与测试
public class Test {
    public static void main(String args[]) {
        Complex complex1 = new Complex();//复数1
        Complex complex2 = new Complex();//复数2
        
        //使用Scanner读入两复数
        Scanner reader = new Scanner(System.in);
        //读入第一个复数
        System.out.println("请输入第一个复数的实部和虚部：");
        complex1.real = reader.nextDouble();//读入实部
        complex1.imaginary = reader.nextDouble();//读入虚部
        //读入第二个复数
        System.out.println("请输入第二个复数的实部和虚部：");
        complex2.real = reader.nextDouble();//读入实部
        complex2.imaginary = reader.nextDouble();//读入虚部
        
        //停止输入
        reader.close();
        
        //创建operate对象
        Operation operate = new Operation();
        
        //通过operate实现两复数相加
        Complex addtion = operate.add(complex1, complex2);
        //输出相加后的结果
        System.out.println("两复数相加后实部和虚部分别为");
        addtion.print();
        
        //通过operate实现两复数相减
        Complex sub = operate.sub(complex1, complex2);
        //输出相减后的结果
        System.out.println("两复数相减后实部和虚部分别为");
        sub.print();
        
        //输出第一个复数的模长
        System.out.println("第一个复数的模长为："+Operation.abs(complex1));
        //输出第一个复数的辐角
        System.out.println("第一个复数的辐角为："+Operation.arg(complex1));
        
        //创建calculte对象
        Calculate calculate = new Calculate();
        
        //通过calculate实现两复数相乘
        Complex mul = calculate.multiple(complex1, complex2);
        //输出相乘后的结果
        System.out.println("两复数相乘后实部和虚部分别为");
        mul.print();
        
        //通过calculate实现两复数相除
        Complex div = calculate.div(complex1, complex2);
        //输出相除后的结果
        System.out.println("两复数相除后实部和虚部分别为");
        div.print();
    }
}

运行结果：

作业3：

作业要求：

编写一个线段类 MyLine，要求如下:
主要属性有： x ，y ；类型为Point (查看API)
编写构造方法，如 MyLine(Point p1 , Point p2)
编写5个成员方法。如：
检查线段是否位于第一象限check()…
求线段的长度 length() …
判断两条直线是否相交(另一线段作为参数)。
编写一点到该线段（或延长线）的距离
其他方法。
注：编写方法时，考虑利用Point类的方法
编写测试程序
该作业要求编程并调试通过。对你设计的类要有详细的文字
说明（类所封装的内容，属性、方法的功能与含义等）

代码：

package homework3;

import java.awt.Point;
import java.math.*;
import java.util.Scanner;

class MyLine {
    Point x,y;
    
    public MyLine(){}//构造方法
    
    //构造方法
    public MyLine(Point p1,Point p2){
        x = p1;
        y = p2;
    }
    
    //检查线段是否位于第一象限
    public boolean check() {
        if (x.x > 0 && x.y > 0 && y.x > 0 && y.y > 0) return true;
        else return false;
    }
    
    //求线段的长度 
    public double length() {
        return Math.sqrt((x.y-x.x)*(x.y-x.x)+(y.y-y.x)*(y.y-y.x));
    }
    
    //判断两条线段是否相交
    public boolean intersection(MyLine bLine) {
           /*
               *快速排斥：
               *两个线段为对角线组成的矩形，如果这两个矩形没有重叠的部分，那么两条线段是不可能出现重叠的
            */
           if(!(Math.min(this.x.x,this.y.x)<=Math.max(bLine.x.x,bLine.y.x) &&
                Math.min(bLine.x.y,bLine.y.y)<=Math.max(this.x.y,this.y.y)&&
                Math.min(bLine.x.x,bLine.y.x)<=Math.max(this.x.x,this.y.x) && 
                Math.min(this.x.y,this.y.y)<=Math.max(bLine.x.y,bLine.y.y)))
           return false;
           /*
            *跨立实验：
            *如果两条线段相交，那么必须跨立，就是以一条线段为标准，另一条线段的两端点一定在这条线段的两段
            *也就是说a b两点在线段cd的两端，c d两点在线段ab的两端
            */
           double u,v,w,z;//分别记录两个向量
           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);
           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);
           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);
           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);
           return (u*v<=0.00000001 && w*z<=0.00000001);
    }
    
    //一点到该线段（或延长线）的距离
    public double distancePointToMyLine(Point aPoint) {
        double A = x.y - y.y;
        double B = y.x - x.x;
        double C = x.x*y.y-x.y*y.x;
        double dis = (Math.abs(A*aPoint.x+B*aPoint.y+C)/Math.sqrt(A*A+B*B));
        return dis;
    }
    
    //判断点是否在线段所在直线上
    public boolean pointOnMyLine(Point aPoint) {
        return ((y.y-x.y)/(y.x-x.x) == (aPoint.y - x.y)/(aPoint.x-x.x));
    }
}

public class Test{
    public static void  main(String args[]) {
        
        Scanner reader = new Scanner(System.in);
        
        //输入第一条线段的左端点的横纵坐标
        Point ax = new Point();
        System.out.println("请输入第一条线段的左端点的横纵坐标");
        ax.x = reader.nextInt();
        ax.y = reader.nextInt();
        
        //第一条线段的右端点的横纵坐标
        Point ay = new Point();
        System.out.println("请输入第一条线段的右端点的横纵坐标");
        ay.x = reader.nextInt();
        ay.y = reader.nextInt();
        
        MyLine aLine = new MyLine(ax,ay);
        
        //输入第二条线段的左端点的横纵坐标
        Point bx = new Point();
        System.out.println("请输入第二条线段的左端点的横纵坐标");
        bx.x = reader.nextInt();
        bx.y = reader.nextInt();
        
        //输入第一条线段的右端点的横纵坐标
        Point by = new Point();
        System.out.println("请输入第一条线段的右端点的横纵坐标");
        by.x = reader.nextInt();
        by.y = reader.nextInt();
        
        MyLine bLine = new MyLine(bx,by);
        
        //检查线段是否位于第一象限
        if (aLine.check()){
            System.out.println("aLine在第一象限");
        }else System.out.println("aLine不在第一象限");
        
        //求线段的长度 
        System.out.println("aLine的长度是："+aLine.length());
        
        //判断两条线段是否相交
        if (aLine.intersection(bLine)){
            System.out.println("aLine和bLine相交");
        }else System.out.println("aLine和bLine不相交");
        
        //输入一个点的坐标，然后求该点到aLine的距离
        Point point = new Point();
        System.out.println("请输入点的横纵坐标：");
        point.x = reader.nextInt();
        point.y = reader.nextInt();
        //一点到该线段（或延长线）的距离
        System.out.println("点到aLine的距离为："+aLine.distancePointToMyLine(point));
        
        //判断点是否在线段所在直线上
        if(aLine.pointOnMyLine(point)){
            System.out.println("点在线段所在直线上");
        }else System.out.println("点不在线段所在直线上");
    }
}

运行结果：

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

package task4;

public class BookCard {
    int rno;
    String rname;
    Book [] books = new Book [10];
    BookCard(int p1,String p2,Book[] p3){
        rno = p1;
        rname = p2;
        books = p3;
    }

    //取读者号
    int getRno(){
        return rno;
    }
    
    //取读者名
    String getRname(){
        return rname;
    }
    
    //统计在借图书数
    int bnum(){
        return books.length;
    }
    
    //借书
    boolean borrow(Book b){
        if (books.length == 10) return false;
        else {
            int len = books.length;
            books[len-1] = b;
            return true;
        }
    }
    
    //还书
    boolean returnBook(String s){
        for (int i = 0;i < books.length;++i){
            if (books[i] != null && books[i].bname == s){
                int len = books.length;
                books[i] = books[len-1]; 
                books[len-1] = null;
                return true;
            }
        }
        return false;
    }
    
    //输出在借书名清单
    void printBooks(){
        for(int i = 0;i < books.length;++i) {
            System.out.println(books[i].getName());
        }
    }
    
    //统计出在借图书中定价高于参数p的图书册数
    int  expensive(int p){
        int count = 0;
        for(int i = 0;i < books.length;++i) {
            if(books[i] != null && books[i].getPrice() > p) count++;
        }
        return count;
    }
    
    //找出所有在借图书中书名包括该关键词的图书
    String[] search(String s){
        String[] ret = new String[10];
        int cnt = 0;
        for(int i = 0;i < books.length;++i) {
            if(books[i] != null && books[i].getName().indexOf(s) != -1) ret[cnt++] = books[i].getName();
        }
        return ret;
    }
    
    
}

package task4;

public class Test {
    public static void main(String args[]){
        Book b1 =new Book("离散数学及其应用",23);
        Book b2 = new Book("大学计算机基础",32);
        Book b3 = new Book("Java面向对象程序设计",40);
        Book b4 = new Book("C++程序设计", 65);
        Book b5 = new Book("大学英语", 12);
        Book[] books={b1,b2,b3,b4,b4,b5,b5,b4,b5};
        BookCard b = new BookCard (216132,"xxx",books);
        
        System.out.println("读者号:" + b.getRno() + " 读者名:" + b.getRname() + " 在借图书数目:" + b.bnum());
        //输出已经借了的图书
        System.out.println("在借图书有：");
        b.printBooks();
        
        //借书测试
        if (b.borrow(b5)){
            System.out.println(b5.bname+"借书成功!");
        }else System.out.println(b5.bname+"借书失败！");
        
        //借书测试
        if (b.borrow(b5)){
            System.out.println(b5.bname+"借书成功!");
        }else System.out.println(b5.bname+"借书失败！");
        
        //还书测试
        if(b.returnBook("离散数学及其应用")) {
            System.out.println("离散数学及其应用还书成功!");
        }else System.out.println("离散数学及其应用还书失败！");
        
        //还书测试
        if(b.returnBook("离散数学及其应用")) {
            System.out.println("离散数学及其应用还书成功!");
        }else System.out.println("离散数学及其应用还书失败！");
        
        
        //寻找定价高于33的书
        System.out.println("定价高于33的书有:" + b.expensive(33) + "本");
        
        //寻找书名中含C的书
        System.out.println("书名内包含C的书有:");
        String[] cout = b.search("C");
        for(int i = 0;cout[i] != null;++i) {
            System.out.println(cout[i]);
        }
        
    }
}

运行结果：