JAVA作业4&实验4

最新推荐文章于 2024-02-10 12:42:10 发布
最新推荐文章于 2024-02-10 12:42:10 发布
阅读量4.6k 收藏 31
点赞数 3
分类专栏： JAVA 文章标签： java 类 面向对象编程 程序设计 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_iron_man/article/details/112206879
版权

6-1 Shape类 (20分)

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()

在main函数中，分别构造三个子类的对象，并输出他们的周长、面积. 提示：用System.out.printf("%.2f",d)进行格式化输出

输入描述：
正方形类的边长 长方形类的长宽 圆类的半径

输出描述：
正方形的周长、面积 长方形的周长、面积

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         double length = scan.nextDouble();
         Square s = new Square(length);
         System.out.printf("%.2f ",s.getPerimeter());
         System.out.printf("%.2f\n",s.getArea());

         length = scan.nextDouble();
         double wide = scan.nextDouble();
         Rectangle r = new Rectangle(length,wide);
         System.out.printf("%.2f ",r.getPerimeter());
         System.out.printf("%.2f\n",r.getArea());

         double radius = scan.nextDouble();
         Circle c = new Circle(radius);
         System.out.printf("%.2f ",c.getPerimeter());
         System.out.printf("%.2f\n",c.getArea());

         scan.close(); 
    }
}

/* 你的代码被嵌在这里 */

输入样例：
在这里给出一组输入。例如：

1
1 2
2

输出样例：
在这里给出相应的输出。例如：

4.00 1.00
6.00 2.00
12.57 12.57

ans:

abstract class Shape
{
    abstract public double getPerimeter();
    abstract public double getArea();
}
class Square extends Shape{
	private double a;
	public Square(double a)
	{
		this.a=a;
	}
	public double getPerimeter()
	{
		return 4*a;
	}
	public double getArea()
	{
		return a*a;
	}
}
class Rectangle extends Shape{
	private double a,b;
	public Rectangle (double a,double b) {
		this.a=a;
		this.b=b;
	}
	public double getPerimeter()
	{
		return 2*(a+b);
	}
	public double getArea()
	{
		return a*b;
	}
}
class Circle extends Shape{
	private double r;
	double PI=3.1415926;
	public Circle(double r)
	{
	   this.r=r;	
	}
	public double getPerimeter()
	{
		return 2*PI*r;
	}
	public double getArea()
	{
		return PI*r*r;
	}
}

6-2 学生、大学生、研究生类 (20分)

定义Student学生类，拥有学号、姓名、性别属性，提供构造函数，以及相应属性的get set函数，提供函数attendClass(String className)表示上课。 定义CollegeStudent大学生类继承自Student类，拥有新增属性专业，提供构造函数，提供新增属性的get和set函数 定义GraduateStudent研究生类继承自CollegeStudent类，拥有新增属性导师，提供构造函数，提供新增属性的get和set函数，提供函数doResearch() 表示做研究（打印xx is doing research）。

main函数中对构造的类进行测试

输入描述：
学生类信息，学号、姓名、性别 大学生类信息，学号、姓名、性别、专业 研究生类信息，学号、姓名、性别、专业、导师

输出描述：
学生类信息 大学生类信息 研究生类信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);      
         int no = scan.nextInt();
         String name = scan.next();      
         String sex = scan.next();      
         Student s = new Student(no, name, sex);
         s.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         String major = scan.next();
         CollegeStudent c = new CollegeStudent(no, name, sex, major);
         c.print();

         no = scan.nextInt();
         name = scan.next();      
         sex = scan.next();      
         major = scan.next();
         String supervisor = scan.next();
         GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor );
         g.print();
         g.doResearch();
         scan.close(); 
    }
}

/* 你的代码被嵌在这里*/

输入样例：
在这里给出一组输入。例如：

1 liu female
2 chen female cs
3 li male sc wang

输出样例：
在这里给出相应的输出。例如：

no: 1
name: liu
sex: female
no: 2
name: chen
sex: female
major: cs
no: 3
name: li
sex: male
major: sc
supervisor: wang
li is doing research

ans:

class Student
{
    private int no;
    private String name;
    private String sex;
    public Student(int no,String name,String sex)
    {
        this.no=no;
        this.name=name;
        this.sex=sex;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String attendClass (String className)
    {
        return className;
    }
    public void print()
    {
        System.out.println("no: "+getNo());
        System.out.println("name: "+getName());
        System.out.println("sex: "+getSex());
    }
}
class CollegeStudent extends Student
{
    private String major;
    public CollegeStudent(int no,String name,String sex,String major )
    {
        super(no,name,sex);//继承父类变量
        this.major=major;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }
    public void print()
    {
        super.print();
        System.out.println("major: "+getMajor());
    }
}
class GraduateStudent extends CollegeStudent{
    private String supervisor;
    public GraduateStudent(int no,String name,String sex,String major,String supervisor)
    {
        super(no,name,sex,major);
        this.supervisor=supervisor;
    }
    public String getSupervisor() {
        return supervisor;
    }
    public void setSupervisor(String supervisor) {
        this.supervisor = supervisor;
    }
    public void doResearch()
    {
        System.out.println(getName()+" is doing research");
    }
    public void print()
    {
        super.print();
        System.out.println("supervisor: "+getSupervisor());
    }
}

super:将被隐藏的父类的成员变量和成员方法变为可见，或者说用来引用被隐藏的父类的成员变量和成员方法。

6-3 租车服务 (20分)

某租车公司提供租车服务，针对不同的车辆类型，日租金的计算方式不同，具体地，对于货车而言，根据载重量load（单位是吨）计算，公式为loadx 1000；对于大型客车而言，根据车内座位数seats计算，公式为seatsx50；对于小型汽车而言，根据车辆等级和折旧年数计算，公式为200*level/sqrt(year)，其中sqrt表示平方根。设计合适的类继承结构实现上述功能，构造租车公司类CarRentCompany，提供静态函数rentVehicles，能够给定一组待租车辆，计算日租金总额。 在main函数中，读入多个车辆数据，并计算总的日租金。

输入描述：
汽车数量 汽车种类 该类汽车相关属性 其中1表示货车，2表示大型客车，3表示小型汽车

输出描述：
总的日租金，保留两位小数

裁判测试程序样例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        Vehicle[] vs = new Vehicle[c];
        for (int i=0;i<c;i++) {
            int type = sc.nextInt();
            Vehicle v = null;
            if (type == 1) {//货车
                vs[i] = new Truck (sc.nextDouble());
            } else if (type == 2) {
                vs[i] = new Keche(sc.nextInt());
            } else if (type == 3) {
                vs[i] = new Car(sc.nextInt(), sc.nextInt());
            }
        }

        System.out.printf("%.2f",CarRentCompany.rentVehicles(vs));

    }
}

/* 你的代码被嵌在这里 */

输入样例：
在这里给出一组输入。例如：

3
1 3
2 50
3 5 5

输出样例：
在这里给出相应的输出。例如：

5947.21

ans:

abstract class Vehicle
{
   public abstract double getRent();
}
class Truck extends Vehicle
{
    double load;

    public Truck(double load)
    {
        this.load=load;
    }
    public double getLoad() {
        return load;
    }

    public void setLoad(double load) {
        this.load = load;
    }

    public double getRent()
    {
        return load*1000;
    }
}
class Keche extends Vehicle
{
    double seats;

    public Keche(double seats) {
        this.seats = seats;
    }

    public double getSeats() {
        return seats;
    }

    public void setSeats(double seats) {
        this.seats = seats;
    }

    public double getRent()
    {
        return seats*50;
    }
}

class Car extends Vehicle
{
    double level;
    double year;

    public Car(double level, double year) {
        this.level = level;
        this.year = year;
    }

    public double getLevel() {
        return level;
    }

    public void setLevel(double level) {
        this.level = level;
    }

    public double getYear() {
        return year;
    }

    public void setYear(double year) {
        this.year = year;
    }

    public double getRent() {
        return 200*level/Math.sqrt(year);
    }
}

class CarRentCompany
{
    public static double rentVehicles(Vehicle vs[])
    {
        double sum=0;
        for(Vehicle v:vs)
        {
               sum+=v.getRent();
        }
        return sum;
    }
}

7-1 员工类 (20分)

假定要为某个公司编写雇员工资支付程序，这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资（都是整数）： （1）经理（Manager）——每月获得一份固定的工资 （2）销售人员（Salesman）——在基本工资的基础上每月还有销售提成 （3）一般工人（Worker）——则按他每月工作的天数计算工资 在Employee中提供函数getSalary()计算每个雇员一个月的工资，并在子类中重写。

在main函数中构造Employee的三个变量，分别指向Manager、Salesman、Worker的对象，调用getSalary函数，输出三个对象的工资

输入格式:
经理的月工资 销售人员的基本工资 销售人员的提成 工人的工作天数 工人每天的工资

输出格式:
经理的工资 销售人员的工资 工人的工资

输入样例:
在这里给出一组输入。例如：

12000
3000 5000
22 200

输出样例:
在这里给出相应的输出。例如：

12000
8000
4400

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int Mwage=cin.nextInt();
        Employee manager=new Manager(Mwage);
        int Swage=cin.nextInt();
        int Scom=cin.nextInt();
        Employee salesman=new Salesman(Swage,Scom);
        int Wdays=cin.nextInt();
        int Wwage=cin.nextInt();
        Employee worker=new Worker(Wdays,Wwage);

        System.out.println(manager.getSalary());
        System.out.println(salesman.getSalary());
        System.out.println(worker.getSalary());

        cin.close();
    }
}
class Employee
{
    int wage;
    public Employee(int wage)
    {
        this.wage=wage;
    }
    public  int getSalary()
    {
        return wage;
    }
}
class Manager extends Employee
{

    public Manager(int wage) {
        super(wage);
    }

    public int getWage() {
        return wage;
    }

    public void setWage(int wage) {
        this.wage = wage;
    }

}

class Salesman extends Employee
{
    int Commission;

    public Salesman(int wage, int commission) {
        super(wage);
        Commission = commission;
    }

    public int getWage() {
        return wage;
    }

    public void setWage(int wage) {
        this.wage = wage;
    }

    public int getCommission() {
        return Commission;
    }

    public void setCommission(int commission) {
        Commission = commission;
    }

    @Override
    public int getSalary()
    {
        return getWage()+getCommission();
    }
}

class Worker extends Employee
{
    int days;

    public Worker(int days, int wage) {
        super(wage);
        this.days = days;
    }

    public int getDays() {
        return days;
    }

    public void setDays(int days) {
        this.days = days;
    }

    @Override
    public int getSalary() {
        return getDays()*wage;
    }
}

7-2 员工类-2 (20分)
修改题目131的员工类，使得Employee类为抽象类，getSalary()方法是抽象方法

输入格式:
经理的月工资 销售人员的基本工资 销售人员的提成 工人的工作天数 工人每天的工资

输出格式:
经理的工资 销售人员的工资 工人的工资

输入样例:
在这里给出一组输入。例如：

12000
3000 5000
22 200

输出样例:
在这里给出相应的输出。例如：

12000
8000
4400

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
             Scanner cin=new Scanner(System.in);
             int Mwage=cin.nextInt();
             Employee manager=new Manager(Mwage);
             int Swage=cin.nextInt();
             int Scom=cin.nextInt();
             Employee salesman=new Salesman(Swage,Scom);
             int Wdays=cin.nextInt();
             int Wwage=cin.nextInt();
             Employee worker=new Worker(Wdays,Wwage);

        System.out.println(manager.getSalary());
        System.out.println(salesman.getSalary());
        System.out.println(worker.getSalary());

        cin.close();
    }
}
abstract class Employee
{
    int wage;
    public Employee(int wage)
    {
        this.wage=wage;
    }
    public abstract int getSalary();
}
class Manager extends Employee
{

    public Manager(int wage) {
        super(wage);
    }

    public int getWage() {
        return wage;
    }

    public void setWage(int wage) {
        this.wage = wage;
    }

    public int getSalary()
    {
        return wage;
    }
}

class Salesman extends Employee
{
    int Commission;

    public Salesman(int wage, int commission) {
        super(wage);
        Commission = commission;
    }

    public int getWage() {
        return wage;
    }

    public void setWage(int wage) {
        this.wage = wage;
    }

    public int getCommission() {
        return Commission;
    }

    public void setCommission(int commission) {
        Commission = commission;
    }

    public int getSalary()
    {
        return getWage()+getCommission();
    }
}

class Worker extends Employee
{
    int days;

    public Worker(int days, int wage) {
        super(wage);
        this.days = days;
    }

    public int getDays() {
        return days;
    }

    public void setDays(int days) {
        this.days = days;
    }

    public int getSalary() {
        return getDays()*wage;
    }
}

7-3 Shape类-2 (20分)

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()

在main函数中，分别构造三个Shape类的变量，分别指向一个Square、Rectangle、Circle对象，并输出他们的周长、面积.

输入格式:
正方形类的边长 长方形类的长宽 圆类的半径

输出格式:
正方形的周长、面积 长方形的周长、面积 圆形的周长、面积

输入样例:
在这里给出一组输入。例如：

1
1 2
2

输出样例:
在这里给出相应的输出。例如：

4.00 1.00
6.00 2.00
12.57 12.57

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double length = scan.nextDouble();
        Shape s = new Square(length);
        System.out.printf("%.2f ",s.getPerimeter());
        System.out.printf("%.2f\n",s.getArea());

        length = scan.nextDouble();
        double wide = scan.nextDouble();
        Shape r = new Rectangle(length,wide);
        System.out.printf("%.2f ",r.getPerimeter());
        System.out.printf("%.2f\n",r.getArea());

        double radius = scan.nextDouble();
        Shape c = new Circle(radius);
        System.out.printf("%.2f ",c.getPerimeter());
        System.out.printf("%.2f\n",c.getArea());

        scan.close();
    }
}

class Shape
{
    private double a;

    public Shape(double a) {
        this.a = a;
    }

    public double getA() {
        return a;
    }

    public void setA(double a) {
        this.a = a;
    }

    public double getPerimeter()
   {
       return a;
   }
   public double getArea()
   {
       return a;
   }
}
class Square extends Shape{
    public Square(double a)
    {
        super(a);
    }
    public double getPerimeter()
    {
        return 4*getA();
    }
    public double getArea()
    {
        return getA()*getA();
    }
}
class Rectangle extends Shape{
    private double b;
    public Rectangle (double a,double b) {
        super(a);
        this.b=b;
    }
    public double getPerimeter()
    {
        return 2*(getA()+b);
    }
    public double getArea()
    {
        return getA()*b;
    }
}
class Circle extends Shape{
    double PI=3.1415926;
    public Circle(double r)
    {
        super(r);
    }
    public double getPerimeter()
    {
        return 2*PI*getA();
    }
    public double getArea()
    {
        return PI*getA()*getA();
    }
}

7-4 Shape类-3 (20分)

修改题目133，将Shape类改为抽象类

输入格式:
正方形类的边长 长方形类的长宽 圆类的半径

输出格式:
正方形的周长、面积 长方形的周长、面积 圆形的周长、面积

输入样例:
在这里给出一组输入。例如：

1
1 2
2

输出样例:
在这里给出相应的输出。例如：

4.00 1.00
6.00 2.00
12.57 12.57

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double length = scan.nextDouble();
        Shape s = new Square(length);
        System.out.printf("%.2f ",s.getPerimeter());
        System.out.printf("%.2f\n",s.getArea());

        length = scan.nextDouble();
        double wide = scan.nextDouble();
        Shape r = new Rectangle(length,wide);
        System.out.printf("%.2f ",r.getPerimeter());
        System.out.printf("%.2f\n",r.getArea());

        double radius = scan.nextDouble();
        Shape c = new Circle(radius);
        System.out.printf("%.2f ",c.getPerimeter());
        System.out.printf("%.2f\n",c.getArea());

        scan.close();
    }
}

abstract class Shape
{
    abstract public double getPerimeter();
    abstract public double getArea();
}
class Square extends Shape{
    private double a;
    public Square(double a)
    {
        this.a=a;
    }
    public double getPerimeter()
    {
        return 4*a;
    }
    public double getArea()
    {
        return a*a;
    }
}
class Rectangle extends Shape{
    private double a,b;
    public Rectangle (double a,double b) {
        this.a=a;
        this.b=b;
    }
    public double getPerimeter()
    {
        return 2*(a+b);
    }
    public double getArea()
    {
        return a*b;
    }
}
class Circle extends Shape{
    private double r;
    double PI=3.1415926;
    public Circle(double r)
    {
        this.r=r;
    }
    public double getPerimeter()
    {
        return 2*PI*r;
    }
    public double getArea()
    {
        return PI*r*r;
    }
}

7-5 学生、大学生、研究生类-2 (20分)

修改题目125（学生类-本科生类-研究生类） 为学生类添加属性成绩，添加相应的get和set函数，添加函数getGrade()表示获得等级，该函数应当为抽象函数。 本科生和研究生的等级计算方式不同，如下所示

本科生标准 研究生标准 [80–100) A [90–100) A [70–80) B [80–90) B [60–70) C [70–80) C [50–60) D [60–70) D 50 以下 E 60 以下 E

main函数中构造两个学生Student变量，分别指向本科生和研究生对象，调用getGrade()方法输出等级

输入格式:
本科生类信息，学号、姓名、性别、专业、成绩 研究生类信息，学号、姓名、性别、专业、导师、成绩

输出格式:
本科生等级 研究生等级

输入样例:
在这里给出一组输入。例如：

2 chen female cs 90
3 li male sc wang 80

输出样例:
在这里给出相应的输出。例如：

A
B


import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int no = scan.nextInt();
        String name = scan.next();
        String sex = scan.next();
        String major = scan.next();
        double score=scan.nextDouble();
        CollegeStudent c = new CollegeStudent(no, name, sex, major,score);
       // c.print();
        c.getGrade();

        no = scan.nextInt();
        name = scan.next();
        sex = scan.next();
        major = scan.next();
        String supervisor = scan.next();
        score=scan.nextDouble();
        GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor ,score);
       // g.print();
        //g.doResearch();
        g.getGrade();
        scan.close();
    }
}

abstract class Student
{
    private int no;
    private String name;
    private String sex;
    private double score;

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public Student(int no, String name, String sex,double score)
    {
        this.no=no;
        this.name=name;
        this.sex=sex;
        this.score=score;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String attendClass (String className)
    {
        return className;
    }
    public abstract void getGrade();

    public void print()
    {
        System.out.println("no: "+getNo());
        System.out.println("name: "+getName());
        System.out.println("sex: "+getSex());
    }
}
class CollegeStudent extends Student
{
    private String major;
    public CollegeStudent(int no,String name,String sex,String major,double score )
    {
        super(no,name,sex,score);
        this.major=major;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }
    public void print()
    {
        super.print();
        System.out.println("major: "+getMajor());
    }
    public  void getGrade()
    {
        int a=0;
        if(getScore()>=80&&getScore()<=100) a=1;
        if(getScore()>=70&&getScore()<80) a=2;
        if(getScore()>=60&&getScore()<70) a=3;
        if(getScore()>=50&&getScore()<60) a=4;
        if(getScore()<50) a=5;
        char b='?';
        switch (a)
        {
            case 1:b='A';break;
            case 2:b='B';break;
            case 3:b='C';break;
            case 4:b='D';break;
            case 5:b='E';break;
            default:break;
        }
        System.out.println(b);
    }
}
class GraduateStudent extends CollegeStudent{
    private String supervisor;
    public GraduateStudent(int no,String name,String sex,String major,String supervisor,double score)
    {
        super(no,name,sex,major,score);
        this.supervisor=supervisor;
    }
    public String getSupervisor() {
        return supervisor;
    }
    public void setSupervisor(String supervisor) {
        this.supervisor = supervisor;
    }
    public void doResearch()
    {
        System.out.println(getName()+" is doing research");
    }
    public void print()
    {
        super.print();
        System.out.println("supervisor: "+getSupervisor());
    }
    public void getGrade()
    {
        int a=0;
        if(getScore()>=90&&getScore()<=100) a=1;
        if(getScore()>=80&&getScore()<90) a=2;
        if(getScore()>=70&&getScore()<80) a=3;
        if(getScore()>=60&&getScore()<70) a=4;
        if(getScore()<60) a=5;
        char b='?';
        switch (a)
        {
            case 1:b='A';break;
            case 2:b='B';break;
            case 3:b='C';break;
            case 4:b='D';break;
            case 5:b='E';break;
            default:break;
        }
        System.out.println(b);
    }
}

6-1 动物体系 (20分)

基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。小狗介绍时输出”My name is xxx, my color is xxx, my IQ is xxx”, 小猫介绍时输出“My name is xxx, my color is xxx, my eyecolor is xxx” 构造类TestAnimal，提供静态函数introduce(Animal)，对参数动物自我介绍。提供静态函数action(Animal)，根据参数对象的实际类型进行活动，如果是小狗，则让其接飞盘，如果是小猫，则让其抓老鼠。 Main函数中，根据动物类型构造动物，并调用TestAnimal中的方法进行自我介绍(introduce)和活动(action)

输入描述：
动物类型 动物名称 动物颜色 动物其他属性 如 1 猫名称 猫颜色 猫眼睛颜色 2 狗名称 狗颜色 狗的智商

输出描述：
自我介绍 活动

裁判测试程序样例：

import java.util.Scanner;

/*你的代码被嵌在这里 */

public class Main{

    public static void main(String args[]) {

        Scanner s = new Scanner (System.in);
        int i = s.nextInt();
        Animal a = null;
        if (i==1) {
            a = new Cat(s.next(), s.next(), s.next());
        } else if (i==2) {
            a = new Dog(s.next(), s.next(), s.nextInt());
        }
        TestAnimal.introduce(a);
        TestAnimal.action(a);

    }
}

输入样例：
在这里给出一组输入。例如：

1 Mikey white blue

输出样例：
在这里给出相应的输出。例如：

My name is Mikey, my color is white, my eyecolor is blue
catch mouse

abstract class Animal{
    String name;
    String color;
    public Animal(String name,String color){
        this.name=name;
        this.color=color;
    }
    abstract public void introduce();
    abstract public void action();
}
class Dog extends Animal{
    int iq;
    public Dog(String name,String color,int iq){
        super(name,color);
        this.iq=iq;
    }
    public void introduce(){
        System.out.println("My name is " + name + ", my color is " + color + ", my IQ is " +iq);
    }
    public void action(){
        System.out.println("catch frisbee");
    }
}
class Cat extends Animal{
    String eyecolor;
    public Cat(String name,String color,String eyecolor){
        super(name,color);
        this.eyecolor=eyecolor;
    }
    public void introduce(){
        System.out.println("My name is " + name + ", my color is " + color + ", my eyecolor is " + eyecolor);
    }
    public void action(){
        System.out.println("catch mouse");
    }
}

class TestAnimal{
    public  static void introduce(Animal animal){
    	animal.introduce();
    }
    public static void action(Animal animal){
    	animal.action();
    }
}

6-2 设计一个Duck类及其子类 (10分)

设计一个Duck类和它的两个子类RedheadDuck和MallardDuck。裁判测试程序中的Main类会自动提交。

类的定义：

//Duck类的定义
class Duck {    }

//RedheadDuck类的定义
class RedheadDuck extends Duck {  }

//MallardDuck类的定义
class MallardDuck extends Duck {   }

裁判测试程序样例：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        Duck rduck = new RedheadDuck();
        rduck.display();
        rduck.quack();
        rduck.swim();
        rduck.fly();    
        Duck gduck = new MallardDuck();
        gduck.display();
        gduck.quack();
        gduck.swim();
        gduck.fly();         
    }
}
/* 请在这里填写答案 */

输入样例：
在这里给出一组输入。例如：

无
输出样例：
在这里给出相应的输出。例如：

我是一只红头鸭
我会呱呱呱
我会游泳
我会飞
我是一只绿头鸭
我会呱呱呱
我会游泳
我会飞

//Duck类的定义
abstract class  Duck {  
	abstract public void display();
	
	public void quack() {
		System.out.println("我会呱呱呱");
	}
	public void swim() {
		System.out.println("我会游泳");
	}

	public void fly() {
		System.out.println("我会飞");
	}

}

//RedheadDuck类的定义
class RedheadDuck extends Duck { 
	public void display()
	{
		System.out.println("我是一只红头鸭");
	}
	
}

//MallardDuck类的定义
class MallardDuck extends Duck { 

	public void display()
	{
		System.out.println("我是一只绿头鸭");
	}
}

6-3 图书和音像租赁 (20分)

图书和音像店提供出租服务，包括图书和DVD的出租。图书包括书名（String，一个词表示）和价格（double），DVD包括片名（String，一个词表示）。它们都是按天出租，但租金计算方式却不同，图书的日租金为图书价格的1%，DVD的日租金为固定的1元。构造图书和DVD类的继承体系，它们均继承自Media类，且提供方法getDailyRent()返回日租金，构造音像店类MediaShop，提供静态函数double calculateRent(Media[] medias, int days)。 在main函数中构造了Media数组，包含图书和DVD的对象，调用calculateRent方法得到并输出租金，保留小数点两位

输入描述：
待租图书和DVD的数量

图书和DVD的详细信息

租借天数

输出描述：
总的租金

裁判测试程序样例：

import java.util.Scanner;

public class Main {
        public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Media[] ms  = new Media[n];
        for (int i=0; i<n; i++) {
            String type = sc.next();
            if (type.equals("book")) {
                ms[i] = new Book(sc.next(), sc.nextDouble());
            }else {
                ms[i] = new DVD(sc.next());
            }
        }
        double rent = MediaShop.calculateRent(ms, sc.nextInt());
        System.out.printf("%.2f", rent);
    }
}

/* 请在这里填写答案 */

输入样例：

5
book Earth 25.3
book Insights 34
dvd AI
dvd Transformer
book Sun 45.6
20

输出样例：

60.98

abstract class Media
{
	String name;
	Double price;

    public Media(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Media(String name) {
        this.name = name;
    }
    abstract double getDailyRent();
}

class Book extends Media {
    public Book(String name, double price) {
        super(name, price);
    }

    double getDailyRent() {
        return super.price * 0.01;
    }
}

class DVD extends Media {
    public DVD(String name) {
        super(name);
    }

    double getDailyRent() {
        return 1;
    }
}

class MediaShop {
    static double calculateRent(Media[] ms, int  days) {
    	int i;
		double rent=0;
		for(i=0;i<ms.length;i++)
		{
			rent+=ms[i].getDailyRent();
		}
		return rent*days;
    }
}

6-4 设计门票（抽象类） (20分)

某学校举办一次活动，需要凭票参加，每张票都有票号和售价。
门票分为3类：当天票，预订票和学生预订票。
当天票价格50。
预订票，提前时间>10天的，售价30；提前10天以内的，售价40；
学生预订票，提前时间>10天的，售价15；提前10天以内的，售价20。

（1）编写抽象类Ticket类，包含以下成员
①属性： number：私有，int型，表示票号；
②方法：

Ticket(int number), 构造方法,初始化票号；
int getPrice(), 返回票价，抽象方法；
String toString()，返回一个字符串，格式为“Number:票号,Price:票价”。
（2）编写Ticket类的子类WalkupTicket，表示当天票，包含以下成员
①方法：
1)WalkupTicket(int number), 构造方法,初始化票号；
2)int getPrice(), 返回票价50。

（3）编写Ticket类的子类AdvanceTicket，表示预订票，包含以下成员
①属性：

leadTime：私有，int型，表示提前预订的天数；
②方法：
AdvanceTicket(int number,int leadTime), 构造方法,初始化票号和提前天数；
int getPrice(), 如果提前天数>10天，票价30，否则，票价40。
（4）编写AdvanceTicket类的子类StudentAdvanceTicket，表示学生预订票，包含以下成员
①属性：

height：私有，int型，表示购票学生的身高（单位厘米）；
②方法：
1）StudentAdvanceTicket(int number,int leadTime,int height), 构造方法,初始化票号、提前天数和身高；
2）int getPrice(),

如果学生身高>120：提前天数>10天，票价20，否则，票价30。 如果学生身高<=120，票价是身高120以上学生的对折。

裁判测试程序样例：

public class Main{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        Ticket a = new WalkupTicket(in.nextInt());
        System.out.println(a.toString());
        Ticket b = new AdvanceTicket(in.nextInt(), in.nextInt());
        System.out.println(b.toString());
        Ticket c = new StudentAdvanceTicket(in.nextInt(), in.nextInt(), in.nextInt());
        System.out.println(c.toString());
    }
}

/* 请在这里填写答案 */

按如下框架设计类后提交即可：

abstract class Ticket {
……
}
class WalkupTicket extends Ticket {
……
}
class AdvanceTicket extends Ticket {
……
}
class StudentAdvanceTicket extends AdvanceTicket {
……
}

输入样例：
输入票号，创建一个WalkupTicket对象。 输入票号和提前天数，创建一个AdvanceTicket对象。 输入票号、提前天数和身高，创建一个StudentAdvanceTicket对象。

1
2 10
3 11 130

输出样例：
输出创建的3个对象的票号和票价（调用toString()方法）。

Number:1,Price:50
Number:2,Price:40
Number:3,Price:20

abstract class Ticket {
  protected int number;
  public Ticket(int number)
  {
	  this.number=number;
  }
  abstract int getPrice();
  public String toString() {
	  return ("Number:"+number+","+"Price:"+getPrice());
  }
  
}
class WalkupTicket extends Ticket {
	WalkupTicket(int number) 
	{
		super(number);
	}
	int getPrice()
	{
		return 50;
	}
}
class AdvanceTicket extends Ticket {
        protected int leadTime;
        AdvanceTicket(int number,int leadTime)
        {
        	super(number);
        	this.leadTime=leadTime;
        }
        int getPrice()
        {
        	if(leadTime>10) return 30;
        	else return 40;
        }
}
class StudentAdvanceTicket extends AdvanceTicket {
	   protected int height;
        StudentAdvanceTicket(int number,int leadTime,int height)
        {
        	super(number,leadTime);
             this.height=height;
        }
        int getPrice()
        {
        	int price;
        	if(height>120)
        	{
        		if(leadTime>10)
        		price=20;
        		else price=30;
        	}
        	else
        	{
        		if(leadTime>10)
            		price=10;
            		else price=15;
        	}
         return price;
        }
}

7-1 打球过程 (20分)

利用模板方法来构造相关类实现下述过程： 各种球类的玩法虽然不同，但是球类比赛的过程是类似的，都包含如下几个步骤： 1球员报道–>2比赛开始–>3比赛–>4比赛结束–>5公布比赛成绩，且其中1 2 4步相同 第3步根据球类不同，玩法不同，第5步根据得分不同，公布方式结果不同 构造类BallMatch表示球类比赛，包含方法compete表示真个比赛过程 构造各个比赛过程的函数checkin,start,play,end,annouceResult 打印信息如下： now checking in now starting now playing football now ending now annoucing result: 2-3 构造类FootballMatch和BasketBallMatch，实现具体的比赛过程。

在main函数中，读入整数i，如果为1，则构造一个足球比赛过程，如果为2则构造一个篮球比赛过程 打印比赛过程

输入格式:
比赛类型 比分

输出格式:
比赛过程信息

输入样例:
在这里给出一组输入。例如：

1 2-3

输出样例:
在这里给出相应的输出。例如：

now checking in
now starting
now playing football
now ending
now annoucing result: 2-3


import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner cin=new Scanner(System.in);
        int num=cin.nextInt();
        String point=cin.next();
        if(num==1){
            BallMatch ball=new FootballMatch(point);
            ball.checkin();
            ball.start();
            ball.play();
            ball.end();
            ball.annouceResult(point);
        }
        if(num==2){
            BallMatch ball=new BasketBallMatch(point);
            ball.checkin();
            ball.start();
            ball.play();
            ball.end();
            ball.annouceResult(point);
        }
        cin.close();
    }
}
abstract class BallMatch{
    private String points;
    public BallMatch(String points){
        this.points=points;
    }
    public String getPoints(){
        return points;
    }
    public void checkin(){
        System.out.println("now checking in");
    }
    public void start(){
        System.out.println("now starting");
    }
    abstract public void play();
    public void end(){
        System.out.println("now ending");
     }
    abstract public void annouceResult(String points);
}
class FootballMatch extends BallMatch{
    public FootballMatch(String points){
        super(points);
    }
    public void play(){
        System.out.println("now playing football");
    }
    public void annouceResult(String points)
    {
        System.out.println("now annoucing result: "+super.getPoints());
    }
}
class BasketBallMatch extends BallMatch{
    public BasketBallMatch(String points)
    {
        super(points);
    }
    public void play()
    {
        System.out.println("now playing basketball");
    }
    public void annouceResult(String points) 
    {
        System.out.println("now annoucing result: "+super.getPoints());
    }
}
_KEVEON
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
北邮 java 作业4 图形化
12-30
北邮 java 作业4 图形化，李颉老师的java第四次作业，图形化
Java——Shape类
热门推荐
Yolanda_Vamper的博客
09-20 1万+
Description 定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter(...
Java 实验四
qq_73848225的博客
07-11 638
根据主方法内容，实现三个类的定义，分别是是ComputerPlayer、PersonPlayer、Game类。其中ComputerPlayer、PersonPlayer要继承Player类。根据主方法中的用法，实现Game类。
JavaEE作业-实验四
最新发布
qq_71654538的博客
02-10 1254
①定义服务接口： 为每个业务实体（如图书、订单、购物车、库存等）定义一个服务接口。②创建服务实现类： 实现服务接口，将具体的业务逻辑封装在实现类中。在实现类中注入相应的DAO实例，通过DAO层完成对数据库的操作。③使用注解标注服务实现类： 使用Spring的@Service注解标识服务实现类，以便Spring能够识别并将其注册为Bean。④在服务实现类中处理业务逻辑： 在服务实现类中编写具体的业务逻辑，处理业务需求，调用DAO层的方法与数据库进行交互。简单的线上图书交易系统的服务层。
6-2 Shape类
m0_73366316的博客
11-07 122
定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
编写一个抽象类Shape
12-23
1、按照要求使用Java进行编码。 1) 编写一个抽象类Shape，其中有抽象方法getArea（）和getPerimeter（） 2) 在Shape类的基础上派生出Rectangle和Circle类，二者都实现了计算面积的方法getArea（）和计算周长的方法getPerimeter（）； 3) 构造main函数，生成Rectangle和Circle对象，并用Shape类型的变量调用Rectangle和Circle对象的getArea（）和getPerim（）方法。
6-1 动物体系 (20分)
雪岩的博客
12-19 4902
6-1 动物体系 (20分) 基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。小狗介绍时输出”My name i
6-1 Shape类 (20分)
雪岩的博客
12-22 7653
java旧题复习 6-1 Shape类 (20分) 定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性
其他。。。。
qq_58372424的博客
12-30 1246
7-1 数组排序 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int a=in.nextInt(); int []b=new int[a]; int index; for(int i=0;i<b.l...
6-3 租车服务 (20分)
雪岩的博客
12-22 2252
java旧题复习 作业4 6-3 租车服务 (20分) 某租车公司提供租车服务，针对不同的车辆类型，日租金的计算方式不同，具体地，对于货车而言，根据载重量load（单位是吨）计算，公式为loadx 1000；对于大型客车而言，根据车内座位数seats计算，公式为seatsx50；对于小型汽车而言，根据车辆等级和折旧年数计算，公式为200*level/sqrt(year)，其中sqrt表示平方根。设计合适的类继承结构实现上述功能，构造租车公司类CarRentCompany，提供静态函数rentVehicles
Java 作业四
qq_73848225的博客
07-11 399
4-1动物体系基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。
合工大Java实验和作业
01-04
老师是张延孔，作业1~9章，实验123
Java计算机操作系统实验
07-24
实验二要求学生模拟作业调度的实现，用高级语言编写和调试多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。 实验三通过编写和调试存储管理的模拟程序以加深对存储管理方案的...
beiyou Java作业 -4
11-29
实验4 基于实验3，设计图形界面，实现员工信息的录入和查询。 该界面上有菜单如下 EmployeeInfoInput（一级菜单） --CommissionEmployee（二级菜单） --BasePlusCommisionEmployee Search（一级菜单） ---...
corejava:Java实验作业
04-03
核心java Java实验作业
JAVA作业3&实验3
super_iron_man的博客
01-03 6742
7-1 多数组排序 (20分) 3个整数数组进行整体排序，根据输入的三个数组的元素，输出排序后的结果（从大到小） 输入格式: 第1个数组的长度 第1个数组的各个元素 第2个数组的长度 第2个数组的各个元素 第3个数组的长度 第3个数组的各个元素 输出格式: 所有数组的整体排序 输入样例: 在这里给出一组输入。例如： 3 79 80 61 3 88 66 77 2 23 90 输出样例: 在这里给出相应的输出。例如： 90 88 80 79 77 66 61 23 将三个数组复制合并到同一个数组中，再
JAVA作业5
super_iron_man的博客
01-04 3638
6-1 图书类 (20分) 构建一个书类Book，包括名称（字符串），价格（整型），作者（字符串，多个作者当做一个字符串处理），版本号（整型），提供带参数的构造函数Book(String name, int price, String author, int edition)，提供该类的toString()和equals()方法，toString方法返回所有成员属性的值的字符串形式，形如“name: xxx, price: xxx, author: xxx, edition: xxx”，当两个Book对象的
JAVA作业2&实验2 类与对象
super_iron_man的博客
01-03 3134
6-1 Person类 (20分) 构造Person类。包括姓名(name)，性别(sex)和年龄(age)。提供所有属性的set和get函数，提供print函数打印其信息 输入描述： 姓名(name)，性别(sex)和年龄(age) 输出描述： 用户信息 裁判测试程序样例： import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner scan = new
广工操作系统实验作业调度java
07-06
广工操作系统实验作业调度是一个使用Java语言开发的项目，旨在帮助学生理解和掌握操作系统中作业调度的相关概念和算法。该项目主要包含以下几个方面的内容。 首先，项目会介绍操作系统中的作业调度的基本概念和任务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值