欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

山科Java作业及实验题

程序员文章站 2022-04-07 18:29:25
动物体系 (20分)基于继承关系编写一个动物体系，具体的动物包含小狗和小猫。每只动物都有名字和颜色，都能够做自我介绍（introduce）。此外，小狗有智商属性（整数），能接飞盘（catchFrisbee()，方法体内输出一行“catch frisbee”即可），小猫有眼睛颜色属性，能抓老鼠（catchMouse()，方法体内输出一行“catch mouse”即可）。各种小动物自我介绍时均介绍自己的姓名和颜色，此外，小狗应介绍自己的智商，小猫应介绍自己的眼睛颜色。小狗介绍时输出”My name is xx...

动物体系 (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型，表示票号；
②方法：

  1. Ticket(int number), 构造方法,初始化票号；
  2. int getPrice(), 返回票价，抽象方法；
  3. String toString()，返回一个字符串，格式为“Number:票号,Price:票价”。

（2）编写Ticket类的子类WalkupTicket，表示当天票，包含以下成员
①方法：
1)WalkupTicket(int number), 构造方法,初始化票号；
2)int getPrice(), 返回票价50。

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

  1. leadTime：私有，int型，表示提前预订的天数；
    ②方法：
  2. AdvanceTicket(int number,int leadTime), 构造方法,初始化票号和提前天数；
  3. int getPrice(), 如果提前天数>10天，票价30，否则，票价40。

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

  1. 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

  1. 修改教师类，使得由多个Teacher对象所形成的数组可以排序（编号由低到高排序），并在main函数中使用Arrays.sort(Object[] a)方法排序
  2. 定义一个类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

输出格式:

总重量

输入样例:

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

5
1 20
2 30
3 25
3 30
2 40

输出样例:

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

145

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 接口 抽象类 面向对象编程

上一篇： Java如何根据当天日期获取本周日期段（Month + Day）

下一篇： 使用Mybatis Plus 自动创建模板文件

推荐阅读