JAVA作业4&实验4

最新推荐文章于 2024-09-29 22:56:50 发布
最新推荐文章于 2024-09-29 22:56:50 发布
阅读量5.2k 收藏 33
点赞数 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
关注
专栏目录
6-1 动物体系 (20分)
雪岩的博客
12-19 5459
6-1 动物体系 (20分) 基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。小狗介绍时输出”My name i
6-2 动物体系 (20 分)
sjyisdog的博客
05-21 668
abstract class Animal{ public abstract void introduce(); } class Dog extends Animal{ String name; String color; int IQ; public Dog(String _name,String _color,int iq){ name = _name; color = _color; IQ = iq; .
PTA 实验四 零基础JAVA语言学习 6-2 设计门票（抽象类） 一招教会你 设计门票（抽象类）某学校举办一次活动，需要凭票参加，每张票都有票号和售价。门票分为3类：当天票，预订票和学
最新发布
2301_77735425的博客
09-29 715
6-2 设计门票（抽象类）分数 25全屏浏览切换布局作者 殷伟凤单位 浙江传媒学院某学校举办一次活动，需要凭票参加，每张票都有票号和售价。门票分为3类：当天票，预订票和学生预订票。当天票价格50。预订票，提前时间>10天的，售价30；提前10天以内的，售价40；学生预订票，提前时间>10天的，售价15；提前10天以内的，售价20。（1）编写抽象类Ticket类，包含以下成员①属性：number：私有，int型，表示票号；
185 - 动物体系
ming_514
11-08 1006
基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外...
6-1 Shape类 (20分)
雪岩的博客
12-22 8422
java旧题复习 6-1 Shape类 (20分) 定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性
6-3 租车服务 (20分)
雪岩的博客
12-22 2816
java旧题复习 作业4 6-3 租车服务 (20分) 某租车公司提供租车服务，针对不同的车辆类型，日租金的计算方式不同，具体地，对于货车而言，根据载重量load（单位是吨）计算，公式为loadx 1000；对于大型客车而言，根据车内座位数seats计算，公式为seatsx50；对于小型汽车而言，根据车辆等级和折旧年数计算，公式为200*level/sqrt(year)，其中sqrt表示平方根。设计合适的类继承结构实现上述功能，构造租车公司类CarRentCompany，提供静态函数rentVehicles
课程作业-基于Java实现web实验登录界面源码+项目说明.zip
10-18
课程作业-基于Java实现web实验登录界面源码+项目说明.zip课程作业-基于Java实现web实验登录界面源码+项目说明.zip课程作业-基于Java实现web实验登录界面源码+项目说明.zip课程作业-基于Java实现web实验登录界面源码+...
北邮 java 作业4 图形化
12-30
【标题】"北邮 java 作业4 图形化" 是北京邮电大学一门Java课程的第四次作业，重点在于利用Java编程实现图形化的界面。在这个作业中，学生们被要求运用面向对象的编程思想，设计并实现一个图形化的系统，可能包括...
JAVA操作系统实验作业调度图形化模拟程序
01-10
**JAVA操作系统实验作业调度图形化模拟程序** 在计算机科学领域，操作系统是管理和控制计算机硬件与软件资源的核心软件。其中，作业调度是操作系统中一个至关重要的部分，它负责决定哪些任务应该获得CPU时间来执行...
基于Android studio开发的推箱子Java小游戏源代码+实验报告（大作业&课设）
09-14
基于Android studio开发的推箱子Java小游戏源代码+实验报告（大作业&课设），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。该项目可以作为毕设、课程...
Java课程大作业基于javaSwing的实验室设备管理系统源码.zip
12-28
Java课程大作业基于javaSwing的实验室设备管理系统源码.zipJava课程大作业基于javaSwing的实验室设备管理系统源码.zipJava课程大作业基于javaSwing的实验室设备管理系统源码.zipJava课程大作业基于javaSwing的实验室...
定义一个形状类（抽象类）以及一个普通成员函数（用来重设形状大小）、两个纯虚成员函数-周长计算函数和面积计算函数
11-27
（1）程序功能简介 定义一个形状类（抽象类）以及一个普通成员函数（用来重设形状大小）、两个纯虚成员函数-周长计算函数和面积计算函数，利用该类及其派生类实现圆形、三角形、矩形和梯形等图形的周长和面积的计算；主函数完成基类和派生类的测试工作。 （2）程序设计说明 ① 定义一个形状类CShape（抽象类），并添加一个普通成员函数（用来重设形状大小，重载成员函数）SetData（）、两个纯虚成员函数-周长计算函数Perimeter（）和面积计算函数Area（）； ② 由CShape派生出一个圆形类CCircle类，进行相应数据成员和成员函数的重新定义； ③ 由CShape派生出一个三角形类CTriangle类，进行相应数据成员和成员函数的重新定义； ④ 由CShape派生出一个矩形类CRectangle类，进行相应数据成员和成员函数的重新定义； ⑤ 由CShape派生出一个梯形类CTrapezia类，进行相应数据成员和成员函数的重新定义； ⑥ 设计测试主函数，通过输入相应的半径、长、宽、高等数据成员，计算相应的周长和面积； ⑦ 仔细考虑数据成员有哪些？分别放到哪些类（包括基类、子类等）中？注意：纯虚函数、抽象类和具体类的声明、定义和使用细节。 （3）程序调试运行 运行程序查看结果，并进行源代码调试和优化。
图书租赁系统
07-11
入库管理(图书入库、期刊入库); 租出登记(图书借阅、期刊借阅) 归还登记(图书归还、期刊归还)） 查询管理(期间借阅查询、期间归还查询、客户借阅查询、客户归还查询) 库存管理(库存明细、库存查询 统计管理(入库期间统计、租出期间统计、归还期间统计、客户统计、租金统计)
实训音像店管理系统的C++源代码.doc
11-22
实训音像店管理系统的C++源代码.doc 学校实训用的
音像店租赁管理系统 ASP
12-16
简单的音像租赁管理系统 ASP技术 有数据库 下载后 需要安装 “Studio 2005+SQL 2000”数据库已经直接连接了 解压后 直接打开 就 ok了~！~
图书租赁系统(纯Java版)
06-10
使用纯Java编写，有几个版本，有练习文件输入输出流的，有练习集合框架的使用的，适合Java初学者
Java——打球过程
Yolanda_Vamper的博客
10-21 1420
Description 利用模板方法来构造相关类实现下述过程： 各种球类的玩法虽然不同，但是球类比赛的过程是类似的，都包含如下几个步骤： 1球员报道--&gt;2比赛开始--&gt;3比赛--&gt;4比赛结束--&gt;5公布比赛成绩，且其中1 2 4步相同 第3步根据球类不同，玩法不同，第5步根据得分不同，公布方式结果不同 构造类BallMatch表示球类比赛，包含方法compete表示真...
设计一个形状类(接口)Shape,方法:求周长和求面积形状类(接口)的子类(实现类):
shr18439436919的博客
07-11 2064
设计一个形状类(接口)Shape,方法:求周长和求面积 形状类(接口)的子类(实现类):
6-47 图书和音像租赁 (20 分)
weixin_59568478的博客
06-30 1194
图书和音像店提供出租服务，包括图书和DVD的出租。图书包括书名（String，一个词表示）和价格（double），DVD包括片名（String，一个词表示）。它们都是按天出租，但租金计算方式却不同，图书的日租金为图书价格的1%，DVD的日租金为固定的1元。构造图书和DVD类的继承体系，它们均继承自Media类，且提供方法getDailyRent()返回日租金，构造音像店类MediaShop，提供静态函数double calculateRent(Media[] medias, int days)。 在main
Java实验4：金融应用编程
实验名称为“Lab4:Java – Financial Application”，在2009年28日进行，面向CS111班级的学生。实验的主要目的是让学生掌握编程技巧，尤其是使用循环结构，回顾第四章的内容。 实验环境包括Windows XP操作系统和JDK...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值