动物体系 (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;
    Animal(String name,String color){
        this.name=name;
        this.color=color;
    }
    public abstract void introduce();
    
}
class Cat extends Animal{
    String eyecolor;
    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 catchMouse() {
        System.out.println("catch mouse");
    }
}
class Dog extends Animal{
    int IQ;
    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 catchFrisbee() {
        System.out.println("catch frisbee");
    }
    
}
class TestAnimal{
    public static void introduce(Animal a) {
        if(a instanceof Dog) {
            Dog dog = (Dog)a;
            dog.introduce();
        }
        else {
            Cat cat = (Cat)a;
            cat.introduce();
        }
    }
    public static void action(Animal a) {
        if(a instanceof Dog) {
            Dog dog = (Dog)a;
            dog.catchFrisbee();
        }
        else {
            Cat cat = (Cat)a;
            cat.catchMouse();
        }
    }
}

图书和音像租赁 (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;
    Media(String name,double price)
    {
        this.name=name;
        this.price=price;
    }
    Media(String name)
    {
        this.name=name;
    }
    public abstract double getDailyRent();
}
class Book extends Media{

    Book(String name,double price)
    {
        super(name,price);
    }
    public double getDailyRent()
    {
        return price*0.01;
    }
}
class DVD extends Media{
    DVD(String name)
    {
       super(name);
    }
    public double getDailyRent(){
        return 1;
    }
}
class MediaShop{
    public static double calculateRent(Media[] medias, int days)
    {
        double sum=0;
		for(int i=0;i<medias.length;i++){
			if(medias[i].name =="book"){
				sum+=medias[i].getDailyRent()*days;
			}
			else{
				sum+=medias[i].getDailyRent()*days;
			}
		}
		return sum;
	}   
}

设计门票（抽象类） (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

class Ticket {
    private int number;
    public int price;
    Ticket(int number){
        this.number=number;
    }
    public int getPrice()
    {
        return price;
    }
    public String toString()
    {
        String res = new String();
        res+="Number:";
        res+=number;
        res+=",Price:";
        res+=getPrice();
        return res;
    }// 返回一个字符串，格式为“Number:票号,Price:票价”。
}

class WalkupTicket extends Ticket {
    WalkupTicket(int number)    // 构造方法,初始化票号；
    {
        super(number);
    }
    public int getPrice(){
        return 50;
    }
}

class AdvanceTicket extends Ticket {
    private int leadTime;
    AdvanceTicket(int number,int leadTime)
    {
        super(number);
        this.leadTime=leadTime;
    }//构造方法,初始化票号和提前天数；
    public int getPrice() //如果提前天数>10天，票价30，否则，票价40。
    {
        if(this.leadTime>10)
            return 30;
        else
            return 40;
    }
    public int getleadTime()// 这个地方用了一个public函数来返回leadTime变量的值。因为在原题中要求leadTime变量为private，那么如果在他的子函数中直接使用this.leadTime会报错，显示leadTime不可用，但是有个规则：
//子类不能继承父类的私有属性，但如果子类中共有的方法影响到了父类的私有属性，那么私有属性是能够被子类使用的。
//所以以这种形式让子类得到leadTime
    {
        return this.leadTime;
    }
}

class StudentAdvanceTicket extends AdvanceTicket {
    private int height;  //私有，int型，表示购票学生的身高（单位厘米）；
    StudentAdvanceTicket(int number,int leadTime,int height)  //, 构造方法,初始化票号、提前天数和身高；
    {
        super(number,leadTime);
        this.height=height;
    }
    public int getPrice()
    {
        if(this.height>120)
        {
            if(this.getleadTime()>10)//如父类注释。
                return 20;
            else
                return 30;
        }
        else{
            if(this.getleadTime()>10)
                return 10;
            else
                return 15;
        }
    }
}

打球过程 (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

/*
这个题就很好的表现了abstract类的用法，把实例中共同的部分抽象出来，然后在继承之后直接super，剩下特殊的再特殊执行。
*/
import java.util.Scanner;
abstract class BallMatch{
    String points;
    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");
    }
    public abstract void play();
    public void end(){
        System.out.println("now ending");
    }
    public abstract 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());
    }
}


public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int type=cin.nextInt();
        String points=cin.next();
        if(type==1)
        {
           BallMatch ball=new FootballMatch(points);
           ball.checkin();
           ball.start();
           ball.play();
           ball.end();
           ball.annouceResult(points);
        }
        else{
           BallMatch ball=new BasketBallMatch(points);
           ball.checkin();
           ball.start();
           ball.play();
           ball.end();
           ball.annouceResult(points);
        }
    }
}

图书类 (20分)

构建一个书类Book，包括名称（字符串），价格（整型），作者（字符串，多个作者当做一个字符串处理），版本号（整型），提供带参数的构造函数Book(String name, int price, String author, int edition)，提供该类的toString()和equals()方法，toString方法返回所有成员属性的值的字符串形式，形如“name: xxx, price: xxx, author: xxx, edition: xxx”，当两个Book对象的名称(不关心大小写，无空格)、作者(不关心大小写，无空格)、版本号相同时，认为两者表示同一本书。 Main函数中，读入两本书，输出他们是否相等，打印两本书的信息。

输入描述：

两本书信息

输出描述：

两本书的打印信息两本书是否相等

裁判测试程序样例：

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Book b1 = new Book(s.next(),
                s.nextInt(),
                s.next(),
                s.nextInt());
        Book b2 = new Book(s.next(),s.nextInt(),s.next(),s.nextInt());

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b1.equals(b2));

    }

}

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

输入样例：

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

ThinkingInJava
86
BruceEckel
4
CoreJava
95
CayS.Horstmann
10

输出样例：

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

name: ThinkingInJava, price: 86, author: BruceEckel, edition: 4
name: CoreJava, price: 95, author: CayS.Horstmann, edition: 10
false

class Book
{
    String name;
    int price;
    String author;
    int edition;
    Book(String name, int price, String author, int edition)
    {
        this.name=name;
        this.price=price;
        this.author=author;
        this.edition=edition;
    }
    
    public String toString(){
        return "name: "+name+", price: "+price+", author: "+author+", edition: "+edition;
    }
    
    public boolean equals(Object o) {
        Book b=(Book)o;
        if( b.edition==this.edition && 
           b.name.equalsIgnoreCase(this.name)&&
           	b.author.equalsIgnoreCase(this.author) )
            return true;
        else
            return false;
    }
}

手机类 (20分)

构造手机类，包含其配置信息：型号（字符串）、内存大小（整数）、存储空间（整数，GB为单位）、价格（整数）。提供带参数的构造函数，重写其equals方法，使得两个相同配置（型号、内存、存储相同即可，价格可不同）的手机为相等的手机。重写其toString函数，打印手机的配置信息，形式为CellPhone [model:xxx, memory:xxx, storage:xxx, price:xxx] main函数中从键盘读入两个手机对象，比较他们是否相等，输出他们的配置信息。

输入描述：

两个计算机对象，包含型号、内存、存储空间、价格

输出描述：

两个对象是否相等，两个对象的配置信息

裁判测试程序样例：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        CellPhone c1 = new CellPhone(sc.next(),sc.nextInt(),sc.nextInt(),sc.nextInt());
        CellPhone c2 = new CellPhone(sc.next(),sc.nextInt(),sc.nextInt(),sc.nextInt());

        System.out.println(c1.equals(c2));
        System.out.println(c1);
        System.out.println(c2);
    }
}

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

输入样例：

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

P20 8 64 4999
P20 8 64 4999

输出样例：

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

true
CellPhone [model:P20, memory:8, storage:64, price:4999]
CellPhone [model:P20, memory:8, storage:64, price:4999]

class CellPhone
{
    String model;
    int memory;
    int storage;
    int price;
    
    CellPhone(String m,int me,int st,int pr)
    {
        this.model=m;
        this.memory=me;
        this.storage=st;
        this.price=pr;
    }
    
    public String toString(){
        return "CellPhone [model:"+model+", memory:"+memory+", storage:"+storage+", price:"+price+"]";
    }
    
    public boolean equals(Object o) {
        CellPhone b=(CellPhone)o;	//声明为Object，再强转为cellphone
        if(b.memory==this.memory && b.model.equalsIgnoreCase(this.model)&&b.storage==this.storage)
            return true;
        else
            return false;
    }
}

可定制排序的矩形 (20分)

从键盘录入表示矩形个数的数字n，然后录入n个矩形的长和宽，然后对这n个矩形按照面积从大到小排序，并输出排序后的每个矩形的面积要求：根据题目中的附加代码，提供RectangleComparator的实现

输入描述:

矩形个数，每个矩形的长和宽

输出描述:

由大到小排序的每个矩形的面积

裁判测试程序样例：

import java.util.Comparator;
import java.util.Arrays;
import java.util.Scanner;

class Rectangle {
    private int length;
    private int width;

    public Rectangle(int length, int width) {
        this.length = length;
        this.width = width;
    }

    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }

    public int getArea(){
        return this.length*this.width;
    }

    @Override
    public String toString() {
        return length + ", " + width;
    }
}

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

public class Main {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        //输入矩形个数
        int num_rectangle = scan.nextInt();
        Rectangle[]  recs = new Rectangle[num_rectangle];
        //输入每个矩形的长和宽
        for(int i=0;i<num_rectangle;i++){
            int length = scan.nextInt();
            int width = scan.nextInt();
            Rectangle rec = new Rectangle(length,width);
            recs[i] = rec;
        }
        //按照面积由大到小排序
        Arrays.sort(recs, new RectangleComparator());
        //打印前n-1个矩形的面积
        for(int i=0;i<recs.length-1;i++){
            System.out.print(recs[i].getArea()+",");
        }
        //打印最后一个矩形的面积
        System.out.print(recs[recs.length-1].getArea());
        scan.close();
    }
}

输入样例：

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

3 1 2 3 4 2 3

输出样例：

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

12,6,2

class RectangleComparator implements Comparator<Rectangle>
{
    public int compare(Rectangle a, Rectangle b)
    {
        return b.getArea()-a.getArea();
    }
}

教师类 (20分)

设计一个教师类Teacher,要求：属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应的get和set方法。为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。重写Teacher类的toString方法，通过该方法可以返回“no: , name:, age: **, seminary: **”形式的字符串。

输入格式:

两个教师对象的编号，姓名，年龄，学院

输出格式:

教师的信息两个教师是否相等

输入样例:

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

1 Linda 38 SoftwareEngineering
2 Mindy 27 ComputerScience

输出样例:

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

no: 1, name:Linda, age: 38, seminary: SoftwareEngineering
no: 2, name:Mindy, age: 27, seminary: ComputerScience
false

import java.util.Scanner;
class Teacher{
    int no;
    String name;
    int age;
    String seminary;
    
    Teacher(int no,String name, int age,String seminary)
    {
        this.no=no;
        this.name=name;
        this.age=age;
        this.seminary=seminary;
    }
    
    public String toString()
    {
        return "no: "+no+", name:"+name+", age: "+age+", seminary: "+seminary;
    }
    
    public boolean equals(Object o)
    {
        Teacher b=(Teacher) o;
        if(this.no==b.no)
            return true;
        else
            return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        Teacher a=new Teacher(cin.nextInt(),cin.next(),cin.nextInt(),cin.next());
        Teacher b=new Teacher(cin.nextInt(),cin.next(),cin.nextInt(),cin.next());
        
        System.out.println(a);
        System.out.println(b);
        System.out.println(a.equals(b));
    }
}

教师类-2 (20分)

修改题目143

修改教师类，使得由多个Teacher对象所形成的数组可以排序（编号由低到高排序），并在main函数中使用Arrays.sort(Object[] a)方法排序
定义一个类TeacherManagement，包含教师数组，提供方法add(Teacher[])，使其可以添加教师，提供重载方法search，方法可以在一组给定的教师中，根据姓名或年龄返回等于指定姓名或年龄的教师的字符串信息，信息格式为：“no: , name:, age: **, seminary: **”。如果没有满足条件的教师，则返回“no such teacher”。

输入格式:

教师个数教师信息待查找教师的姓名待查找教师的年龄

输出格式:

排序后的信息按姓名查找的老师信息按年龄查找的老师信息

输入样例:

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

4
3 Linda 38 SoftwareEngineering
1 Mindy 27 ComputerScience
4 Cindy 28 SoftwareEngineering
2 Melody 27 ComputerScience
Cindy
27

输出样例:

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

no: 1, name: Mindy, age: 27, seminary: ComputerScience
no: 2, name: Melody, age: 27, seminary: ComputerScience
no: 3, name: Linda, age: 38, seminary: SoftwareEngineering
no: 4, name: Cindy, age: 28, seminary: SoftwareEngineering
search by name:
no: 4, name: Cindy, age: 28, seminary: SoftwareEngineering
search by age:
no: 1, name: Mindy, age: 27, seminary: ComputerScience
no: 2, name: Melody, age: 27, seminary: ComputerScience

import java.util.Scanner;
import java.util.Arrays;

class TeacherManagement{
    int num;
    Teacher[] Teachers;	//类中声明数组
    TeacherManagement(int Num) {
        num = Num;
        Teachers = new Teacher[num]; //构造函数 ，生成一个数组 
    }
     public void add(Teacher teacher,int i) {	//将一个teacher写入数组
        Teachers[i] = new Teacher(teacher.getNo(),teacher.getName(),teacher.getAge(),teacher.getSeminary());
    }
    
    public void sort(){
        Arrays.sort(Teachers);	//调用Arrays.sort
    }
    
    public void search(String name) {	//按照姓名查找
        int flag = 0;
        System.out.println("search by name:");
        for (int i = 0; i < num; i++) {
            if (Teachers[i].getName().equals(name)) {	
                flag = 1;
                System.out.println(Teachers[i].toString());
            }
        }
        if (flag == 0) {
            System.out.println("no such teacher");
        }
    }
    public void search(int age) {
        int flag = 0;
        System.out.println("search by age:");
        for (int i = 0; i < num; i++) {
            if (Teachers[i].getAge()==age) {
                flag = 1;
                System.out.println(Teachers[i].toString());
            }
        }
        if (flag == 0) {
            System.out.println("no such teacher");
        }
    }
    public void print() {
        for (Teacher teacher : Teachers) {
            System.out.println(teacher.toString());
        }
    }
}

class Teacher implements Comparable{// 这里继承Comparable接口，函数内对CompareTo()重写
    int no;
    String name;
    int age;
    String seminary;
    
    Teacher(int no,String name, int age,String seminary)
    {
        this.no=no;
        this.name=name;
        this.age=age;
        this.seminary=seminary;
    }
    public void setAge(int age) {
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setNo(int no) {
        this.no = no;
    }
 
    public void setSeminary(String seminary) {
        this.seminary = seminary;
    }
 
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
 
    public int getNo() {
        return no;
    }
 
    public String getSeminary() {
        return seminary;
    }

    public String toString()
    {
        return "no: "+no+", name: "+name+", age: "+age+", seminary: "+seminary;
    }

    public boolean equals(Object o)	//对equals进行重写
    {
        Teacher b=(Teacher) o;
        if(this.no==b.no)
            return true;
        else
            return false;
    }
    public int compareTo(Object o) { //这里对compareTo()重写，这样就可以在调用sort函数时，进行
        							//比较的方法按照此来进行。
        Teacher obj = (Teacher) o;
        if (this.no < obj.no)
            return -1;
        else if (this.no == obj.no)
            return 0;
        else
            return 1;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        TeacherManagement ts = new TeacherManagement(n);
        for(int i = 0;i < n;i++)
        {
            Teacher t = new Teacher(cin.nextInt(),cin.next(),cin.nextInt(),cin.next());
            ts.add(t,i);
        }
        ts.sort();
        ts.print();
        String tmp = cin.next();
        int s = cin.nextInt();
        ts.search(tmp);
        ts.search(s);
    }
}

家电类 (20分)

某大型家电企业拥有一批送货卡车，运送电视机、洗衣机、空调等家电。编程计算每个卡车所装载货物的总重量。要求有一个Appliance（家电）接口和有三个实现类TV、WashMachine和AirConditioner，这些类能够提供自重。有一个Truck类，包含了该货车上的所有家电，用一个集合（数组或集合类）表示。 Main函数中程序能够输出Truck类所装载货物的总重量。

输入格式:

家电数量家电种类编号家电重量

注意：各个家电的编号为：TV：1 WashMachine：2 AirConditioner：3

输出格式:

总重量

输入样例:

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

输出样例:

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

import java.util.Arrays;
import java.util.Scanner;
interface Appliance{
    public int getWeight();
}
class App implements Appliance
{
	int weight;
	public int getWeight() 
	{
		return 0;
	}
}
class TV extends App implements Appliance{
    TV(int weight) 
    {
        this.weight = weight;
    }
    public int getWeight() 
    {
        return weight;
    }
}
 
class WashMachine extends App implements Appliance{
    WashMachine(int weight) 
    {
        this.weight = weight;
    }
    public int getWeight() 
    {
        return weight;
    }
}
 
class AirConditioner extends App implements Appliance{
    AirConditioner(int weight) 
    {
        this.weight = weight;
    }
    public int getWeight() 
    {
        return weight;
    }
}

class Truck{
    int n;
    App[] app;
    int sum=0;
    
    public void get()
    {
        Scanner cin = new Scanner(System.in);
        n=cin.nextInt();
        app = new App[n];
        for(int i=0;i<n;i++)
        {
            int type=cin.nextInt();
            if(type == 1)
                app[i] = new TV(cin.nextInt());
            else if(type == 2)
                app[i] = new WashMachine(cin.nextInt());
            else if(type == 3)
                app[i] = new AirConditioner(cin.nextInt());
        }
    }
    public int getsum(){
        for(int i=0;i<n;i++)
        {
            sum+=app[i].getWeight();
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
		Truck truck = new Truck();
		truck.get();
		System.out.println(truck.getsum());
	}
}

本文地址：https://blog.csdn.net/weixin_46760992/article/details/110220739

山科Java作业及实验题

动物体系 (20分)

图书和音像租赁 (20分)

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

打球过程 (20分)

图书类 (20分)

手机类 (20分)

可定制排序的矩形 (20分)

教师类 (20分)

教师类-2 (20分)

家电类 (20分)

相关推荐

java输出流怎么表示

java强制类型转换的规则是什么

java隐式转换规则是什么

java调用js脚本的方法是什么

java怎么调用json接口

java如何获取当前日期

java怎么显示当前时间

shell怎么设置java环境变量