类与对象（2）

一、函数题

一、根据派生类写出基类

裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

函数接口定义：

提示：
观察派生类代码和main方法中的测试代码，补全缺失的代码。

裁判测试程序样例：

注意：真正的测试程序中使用的数据可能与样例测试程序中不同，但仅按照样例中的格式调用相关方法（函数）。

class People{
    protected String id;
    protected String name;

    /** 你提交的代码将被嵌在这里（替换此行） **/

}

class Student extends People{
    protected String sid;
    protected int score;
    public Student() {
        name = "Pintia Student";
    }
    public Student(String id, String name, String sid, int score) {
        super(id, name);
        this.sid = sid;
        this.score = score;
    }
    public void say() {
        System.out.println("I'm a student. My name is " + this.name + ".");
    }

}
public class Main {
    public static void main(String[] args) {
        Student zs = new Student();
        zs.setId("370211X");
        zs.setName("Zhang San");
        zs.say();
        System.out.println(zs.getId() + " , " + zs.getName());

        Student ls = new Student("330106","Li Si","20183001007",98);
        ls.say();
        System.out.println(ls.getId() + " : " + ls.getName());

        People ww = new Student();
        ww.setName("Wang Wu");
        ww.say();

        People zl = new People("370202", "Zhao Liu");
        zl.say();
    }
}

输入样例：

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

（无）

输出样例：

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

I'm a student. My name is Zhang San.
370211X , Zhang San
I'm a student. My name is Li Si.
330106 : Li Si
I'm a student. My name is Wang Wu.
I'm a person! My name is Zhao Liu.

public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
   public  People(){
        
    }  


   public People(String id,String name){
        this.id=id;
        this.name=name;
    }


  public void say(){
      System.out.println("I'm a person! My name is " + this.name +".");
  }
 

二、使用继承，实现“剪刀石头布的游戏”

使用继承，实现“剪刀石头布的游戏”。

小时候很喜欢玩一个游戏，“剪刀石头布”，可以是出拳的形式，或跳格子的形式。现在我们用计算机来玩这个游戏。
电脑用随机数产生剪刀石头布，游戏玩家用输入1，2，3的方式出拳。
游戏玩家输入1或2或3，分别 代表剪刀(1)石头(2)布(3)。
电脑胜出时，显示"Winner is computerPlayer."
游戏玩家胜出时，显示“Winner is personPlayer.”
平局时显示"A Draw."

函数接口定义：

根据主方法内容，实现三个类的定义，分别是是ComputerPlayer、PersonPlayer、Game类。
其中ComputerPlayer、PersonPlayer要继承Player类。
根据主方法中的用法，实现Game类。

裁判测试程序样例：

import java.util.Scanner;

class Player{
    String name;
    Player(String name){
        this.name = name;
    }
    int show() {  //出拳方法
        int show = ( int ) (Math.random() * 10 ) %3  +1;
        return show ;
    }
}
/* 请在这里填写答案 */

public class Main {

    public static void main(String[] args) {
        ComputerPlayer c = new ComputerPlayer ("computer");
        PersonPlayer  p = new PersonPlayer("player ") ;
        Game g = new Game( c ,p );
        g.start();        
    }

}

输入样例：

2

输出样例：

A Draw.

class ComputerPlayer extends Player{
    ComputerPlayer(String name){
        super(name);
    }
     int show() {  //出拳方法
            return super.show();
        }
    
}
class PersonPlayer extends Player {
    PersonPlayer(String name){
        super(name);
        
    }
}
class Game{
    Scanner sc=new Scanner(System.in);
    ComputerPlayer c;
    PersonPlayer d;
    Game(ComputerPlayer c,PersonPlayer d){
        this.c=c;
        this.d=d;
    }
    void start(){
        int s=sc.nextInt();
        if(s==c.show())
        {
            System.out.println("A Draw.");
        }
        else if(s==1&&c.show()==3||s==2&&c.show()==1||s==3&&c.show()==2)
        {
            System.out.print("Winner is personPlayer.");
        }
        else 
            System.out.print("Winner is computerPlayer.");
    }
}

三、设计Worker类及其子类

设计一个Worker类，有以下方法：
（1）构造方法：带两个输入参数：工人的姓名和小时工资。
（2）小时工资的get/set方法
（3）pay()方法：带一个工作时长输入参数，输出："Not Implemented"。
接下来设计Worker的子类：HourlyWorker和SalariedWorker。两个子类都重写继承的方法pay()来计算工人的周薪。计时工按实际工时支付每小时工资，超过40小时的超出部分为双倍工资。计薪工人的工资是40小时的工资，不管工作时间是多少。因为与工作时长无关，故SalariedWorker的方法pay()可以不带参数调用。

###类框架定义：

设计的类如下框架所示，完成后将该三类提交。
class Worker {
    ……
}

class HourlyWorker extends Worker {
        ……
}
class SalariedWorker extends Worker {
        ……
}

裁判测试程序样例：

import  java.util.Scanner;

//Main测试类
public class Main{
  public static void main(String[] args) {
      Scanner input = new Scanner(System.in);
       Worker w1 = new Worker("Joe",15);
      w1.pay(35);
      SalariedWorker w2 = new SalariedWorker("Sue",14.5);
      w2.pay();
      w2.pay(60);
      HourlyWorker w3 = new HourlyWorker("Dana", 20);
      w3.pay(25);
      w3.setRate(35);   
            int h = input.nextInt();     # 输入小时工的工作时长
      w3.pay(h);      
  }
}

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

输入样例：

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

25

输出样例：

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

Not Implemented
580.0
580.0
500.0
875.0

class Worker{ 
    String name;
    double gz;
    int a;
    public Worker(String name,double gz) {
        this.gz=gz;
        this.name=name;
    }
    public double getGz() {
        return gz;
    }
    public void setGz(double gz) {
        this.gz=gz;
    }
    public void pay(int a){
        System.out.println("Not Implemented");
    }
}
class HourlyWorker extends Worker {
    public HourlyWorker(String name,double gz) {
        super(name,gz);
        this.gz=gz;
    }
    public void setRate(int i) {
    this.gz=i;
    }
    public void pay(int a){
        double sum;
        if(a<=40){
        sum=a*this.gz;
        System.out.println(sum);
        }
        else{
            sum=a*this.gz*2;
        System.out.println(sum);
        }
}
}
class SalariedWorker extends Worker {
    public SalariedWorker(String name,double gz) {
        super(name,gz);
        this.gz=gz;
    }
    public void pay() {
        double qi=0;
        qi=40*this.gz;
        System.out.println(qi);
    }
    public void pay(int a) {
        double qi=0;
        qi=40*this.gz;
        System.out.println(qi);
    }
}

四、设计一个Triangle类继承自GeometricObject类

设计一个名为Triangle的类来扩展GeometricObject类。该类包括：

• 三个名为side1、side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0。
• 一个无参构造方法创建默认的三角形。
• 一个能创建带制定side1、side2和side3的三角形的构造方法。
• 所有三个数据域的访问器方法。
• 一个名为getArea()的方法返回这个三角形的面积。
• 一个名为getPerimeter()的方法返回这个三角形的周长。
• 一个名为toString()的方法返回这个三角形的字符串描述，返回的信息包括三角形的颜色、是否填充和三条边的边长。

编写一个测试程序，提示用户输入三角形的三条边、颜色以及一个boolean值表明该三角形是否填充。

程序应该使用输入创建一个具有这些边并设置color和filled属性的三角形。程序应该显示面积、边长、颜色以及表明是否填充的真或者假的值。

裁判测试程序样例：

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        double side1 = input.nextDouble();
        double side2 = input.nextDouble();
        double side3 = input.nextDouble();

        Triangle triangle = new Triangle(side1, side2, side3);

        String color = input.next();
        triangle.setColor(color);

        boolean filled = input.nextBoolean();
        triangle.setFilled(filled);

        System.out.println("The area is " + triangle.getArea());
        System.out.println("The perimeter is " + triangle.getPerimeter());
        System.out.println(triangle);
    }
}

//GeometricObject类
class GeometricObject {
    private String color = "white";
    private boolean filled;
    private java.util.Date dateCreated;

    public GeometricObject() {
        dateCreated = new java.util.Date();
    }

    public GeometricObject(String color, boolean filled) {
        dateCreated = new java.util.Date();
        this.color = color;
        this.filled = filled;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public boolean isFilled() {
        return filled;
    }

    public void setFilled(boolean filled) {
        this.filled = filled;
    }

    public java.util.Date getDateCreated() {
        return dateCreated;
    }

    public String toString() {
        return "color: " + color + " and filled: " + filled;
    }
}

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

输入样例：

输入三角形的三条边、颜色以及一个boolean值表明该三角形是否填充。

3 4 5
red
true

输出样例：

面积、周长、颜色以及表明是否填充的真或者假的值。

The area is 6.0
The perimeter is 12.0
color: red and filled: true
Triangle: side1=3.0 side2=4.0 side3=5.0

class Triangle extends GeometricObject{
    private String color = "white";
    private boolean filled;
    private double side1=1.0,side2=1.0,side3=1.0;
    Triangle(){
        
    }
    Triangle (double side1,double side2,double side3){
        this.side1=side1;
        this.side2=side2;
        this.side3=side3;
    }
    
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public boolean isFilled() {
        return filled;
    }
    public void setFilled(boolean filled) {
        this.filled = filled;
    }
    public double getSide1() {
        return side1;
    }
    public void setSide1(double side1) {
        this.side1 = side1;
    }
    public double getSide2() {
        return side2;
    }
    public void setSide2(double side2) {
        this.side2 = side2;
    }
    public double getSide3() {
        return side3;
    }
    public void setSide3(double side3) {
        this.side3 = side3;
    }
    double getArea() {
        double p=(this.side1+this.side2+this.side3)/2;
        return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
    }
    double getPerimeter() {
        return side1+side2+side3;
    }
    public String toString() {
        return "color: " + color + " and filled: " + filled+"\n"+"Triangle: side1=" + side1 + " side2=" + side2 + " side3=" + side3 ;
    }
    
    
}

五、普通账户和支票账户

编写一个Java程序，包含类Acount、CheckingAccount、Main，其中Main已经实现，请你编写Acount和CheckingAccount类。

(1)编写一个类Account表示普通账户对象，包含以下成员

①属性：

1. id：私有，int型，表示账户编号；
2. balance：私有，int型，表示账户余额；

②方法：

1. Account(), 构造方法，id和balance都初始化为0；
2. Account(int id，int balance)，构造方法，用参数设置账户编号和余额；
3. void setBalance(int balance):修改账户金额
4. int getBalance():返回账户金额
5. boolean withdraw(int money)：从账户提取特定数额，如果余额不足，返回false；否则，修改余额，返回true；
6. void deposit(int money)：向账户存储特定数额。
7. public String toString():将把当前账户对象的信息转换成字符串形式，例如id为123，余额为1000,返回字符串"The balance of account 123 is 1000"。

(2)编写一个Account类的子类CheckingAccount，表示支票账户对象，包含以下成员

①属性：

1. overdraft：私有，int型，表示透支限定额；

②方法：

1. CheckingAccount(), 构造方法，id、balance和overdraft都初始化为0；
2. CheckingAccount(int id，int balance，int overdraft)，构造方法，用参数设置账户编号、余额和透支限定额；
3. boolean withdraw(int money)：从账户提取特定数额，如果超出透支限定额，返回false；否则，修改余额，返回true；

(3)编写公共类Main,实现如下功能

1. 根据用户输入的两个整数id和balance创建普通账户a；
2. 输入一个整数n，表示对账户a有n笔操作；
3. 每笔操作输入一个字符串和一个整数money（表示操作金额）

• 如果字符串为“withdraw”表示取现操作，如果操作成功,输出“withdraw ” + money + “success”，否则输出“withdraw ” + money + “failed”
• 如果字符串为“deposit”表示存入操作，完成操作后输出“deposit” + money + “success”

4. 使用toString方法输出账户a信息。
5. 根据用户输入的三个整数id、balance和overdraft创建支票账户b；
6. 输入一个整数m，表示对账户b有m笔操作；
7. 每笔操作输入一个字符串和一个整数money（表示操作金额）

• 如果字符串为“withdraw”表示取现操作，如果操作成功,输出“withdraw ” + money + “success”，否则输出“withdraw ” + money + “failed”
• 如果字符串为“deposit”表示存入操作，完成操作后输出“deposit” + money + “success”

8. 使用toString方法输出账户b信息。

裁判测试程序样例：

import java.util.Scanner;

public class Main{
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
        int n,m;

        Account a = new Account(input.nextInt(),input.nextInt());
        n = input.nextInt();
        for(int i=0; i < n; i++) {
            String op;
            int money;
            op = input.next();
            money = input.nextInt();
            if(op.equals("withdraw")) {
                if(a.withdraw(money)) {              
                    System.out.println("withdraw " + money + " success");
                } else {
                    System.out.println("withdraw " + money + " failed");
                }
            } else if(op.equals("deposit")) {
                a.deposit(money);
                System.out.println("deposit " + money + " success");
            }
        }      
        System.out.println(a.toString());

        CheckingAccount b = new CheckingAccount(input.nextInt(),input.nextInt(),input.nextInt());
        m = input.nextInt();
        for(int i=0; i < m; i++) {
            String op;
            int money;
            op = input.next();
            money = input.nextInt();
            if(op.equals("withdraw")) {
                if(b.withdraw(money)) {              
                    System.out.println("withdraw " + money + " success");
                } else {
                    System.out.println("withdraw " + money + " failed");
                }
            } else if(op.equals("deposit")) {
                b.deposit(money);
                System.out.println("deposit " + money + " success");
            }
        }      
        System.out.println(b.toString());
    }
}


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

输入样例：

1 100
5
withdraw 200
withdraw 100
deposit 50
deposit 100
withdraw 200
2 100 200
5
withdraw 200
withdraw 100
deposit 50
deposit 100
withdraw 200

输出样例：

withdraw 200 failed
withdraw 100 success
deposit 50 success
deposit 100 success
withdraw 200 failed
The balance of account 1 is 150
withdraw 200 success
withdraw 100 success
deposit 50 success
deposit 100 success
withdraw 200 failed
The balance of account 2 is -50

class Account{
    int d;int f;
    private int id=0;
    private int balance=0;
    public int getId() {
        return id;
    }

    public void deposit(int money) {
        f=f+money;
        
    }

    public boolean withdraw(int money) {
        if(money>f)
        return false;
        if(money<=f)
        f=f-money;
        return true;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }
    public Account() {
        
    }
    public Account(int nextInt, int nextInt2) {
        
        d=nextInt;f=nextInt2;
    }
    
    public String toString() {
        return "The balance of account "+d+" is "+f;
    }
}
class CheckingAccount extends Account{
    private int overdraft;
    int zhanghao;int y;int t;
    public CheckingAccount() {
        
    }
    public CheckingAccount(int nextInt, int nextInt2, int nextInt3) {
        zhanghao=nextInt;y=nextInt2;t=nextInt3;
    }

    public int getOverdraft() {
        return overdraft;
    }

    public void setOverdraft(int overdraft) {
        this.overdraft = overdraft;
    }
    public boolean withdraw(int money) {
        if(money>t+y)
            return false;
        if(money<=t+y)
            y=y-money;
            return true;
    }
    public void deposit(int money) {
        y=y+money;
        
    }
    public String toString() {
        return "The balance of account "+zhanghao+" is "+y;
}}

六、重写父类方法equals

在类Student中重写Object类的equals方法。使Student对象学号(id)相同时判定为同一对象。

函数接口定义：

在类Student中重写Object类的equals方法。使Student对象学号(id)相同时判定为同一对象。

裁判测试程序样例：

import java.util.Scanner;
class Student {
     int id;
     String name;
     int age;
     public Student(int id,     String name,     int age) {
         this.id = id;
         this.name = name;
         this.age = age;
     }

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

}
public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
        Student s1 = new Student(sc.nextInt(),sc.next(),sc.nextInt());
        Student s2 = new Student(sc.nextInt(),sc.next(),sc.nextInt());
        System.out.println(s1.equals(s2));
        sc.close();
    }
}

输入样例：

1001 Peter 20
1001 Jack 18

输出样例：

true

Boolean equals(Student s){
         if(this.id==s.id)
         {
             return true;
         }
         else
             return false;
     }

七、 jmu-Java-03面向对象基础-覆盖与equals 

有Person类，Company类，Employee类。

其中Employee类继承自Person类，属性为：

private Company company;
private double salary;

现在要求覆盖Employee类的equals方法，两个Employee对象相等的条件是：

1. 其继承自父类Person的属性值都相等，其company属性对象equals返回true，且其salary也相等。

2. salary是double型，比较时，使用DecimalFormat df = new DecimalFormat("#.##");使salary保留两位小数，然后再进行比较。

3. 要考虑company为null的情况。如果均为null返回true

函数接口定义：

public boolean equals(Object obj)

输入样例：

Company c1 = new Company("MicroSoft");
Company c2 = new Company("IBM");
Person e1 = new Employee("Li", 35, true, 60000.124, c1);
Person e2 = new Employee("Li", 35, true, 60000.124, c1);
Person e3 = new Employee("Li", 35, true, 60000.124, c2);
Person e4 = new Employee("Li", 35, true, 60000.123, c2);
Person e5 = new Employee("Li", 35, true, 60000.126, c2);
Person e6 = new Employee("Li", 35, true, 60000.126, null);
System.out.println(e1.equals(e2));
System.out.println(e1.equals(e3));
System.out.println(e3.equals(e4));
System.out.println(e3.equals(e5));
System.out.println(e5.equals(e6));

输出样例：

true
false
true
false
false

public boolean equals(Object obj) {
   if (!super.equals(obj))
    return false;
  Employee other = (Employee) obj;
  if (company == null) {
   if (other.company != null)
    return false;
  } else if (!company.equals(other.company))
   return false;
  DecimalFormat df = new DecimalFormat("#.##");
  if (!df.format(salary).equals(df.format(other.salary)))
   return false;
  return true;
 }

八、从抽象类shape类扩展出一个圆形类Circle 

请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。

public abstract class shape {// 抽象类

public abstract double getArea();// 求面积

public abstract double getPerimeter(); // 求周长

主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。

圆形类名Circle

裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;

abstract class shape {// 抽象类
     /* 抽象方法 求面积 */
    public abstract double getArea( );

    /* 抽象方法 求周长 */
    public abstract double getPerimeter( );
}

/* 你提交的代码将被嵌入到这里 */

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
         double r = input.nextDouble( ); 
        shape c = new  Circle(r);

        System.out.println(d.format(c.getArea()));
        System.out.println(d.format(c.getPerimeter()));
        input.close();
    } 
}

输入样例：

3.1415926

输出样例： 

31.0063
19.7392

class Circle extends shape {
    double r;
    public double getArea() {
        return Math.PI*r*r;
    }
    public double getPerimeter() {
        return Math.PI*2*r;
    }
    Circle(double r)
    {
        this.r=r;
    }
}

九、设计门票（抽象类） 

某学校举办一次活动，需要凭票参加，每张票都有票号和售价。
门票分为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

abstract class Ticket {
    private  int number;
    
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    Ticket(int number)
    {
        this.number=number;
    }
    public abstract  int  getPrice();

    public String toString() {
        return "Number:" + number + ",Price:" + getPrice() ;
    }
    
}
class WalkupTicket extends Ticket {

    public WalkupTicket(int number) {
        super(number);
        // TODO Auto-generated constructor stub
    }
     public int getPrice() {
        return 50;
    }
    

    
}
class AdvanceTicket extends Ticket {
    private int leadTime;
    
    public int getLeadTime() {
        return leadTime;
    }

    public void setLeadTime(int leadTime) {
        this.leadTime = leadTime;
    }



    public AdvanceTicket(int number, int leadTime) {
        super(number);
        this.leadTime = leadTime;
    }

    public  int getPrice() {
        if(this.leadTime>10)
            return 30;
        else
            return 40;
    }
    
}
class StudentAdvanceTicket extends AdvanceTicket {
    private int height;

    public StudentAdvanceTicket(int number, int leadTime, int height) {
        super(number, leadTime);
        this.height = height;
    }
    public int getPrice(){
        int s=0;
        if(this.height>120&&getLeadTime()>10)
            s= 20;
        else
            if(this.height>120&&getLeadTime()<=10) 
            s=  30;
    else
        if(height<=120&&getLeadTime()>10) 
                s= 10;
            else if(this.height<=120&&getLeadTime()<=10) 
                s=  15;
        return s;
        
        
    }
    
    
}

十、创建一个直角三角形类实现IShape接口

创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。

interface IShape {// 接口

public abstract double getArea(); // 抽象方法 求面积

public abstract double getPerimeter(); // 抽象方法 求周长

}

###直角三角形类的定义：

直角三角形类的构造函数原型如下：
RTriangle(double a, double b);

其中 a 和 b 都是直角三角形的两条直角边。

裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;

interface IShape {
    public abstract double getArea();

    public abstract double getPerimeter();
}

/*你写的代码将嵌入到这里*/


public class Main {
    public static void main(String[] args) {
        DecimalFormat d = new DecimalFormat("#.####");
        Scanner input = new Scanner(System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        IShape r = new RTriangle(a, b);
        System.out.println(d.format(r.getArea()));
        System.out.println(d.format(r.getPerimeter()));
        input.close();
    }
}

输入样例：

3.1 4.2

输出样例：

6.51
12.5202

class RTriangle implements IShape{
    double a;
    double b;
    public double getArea() {
    return a*b/2;
    }
    public double getPerimeter() {
        return a+b+Math.sqrt(Math.pow(a,2)+Math.pow(b,2));
    }
    
    
    RTriangle(double a, double b){
        this.a=a;
        this.b=b;
    }


}

十一、面积求和 

由于各种图形 求面积的方式不一样，为了使编写的程序能够适应求不同形状的面积和，当新增加一个图形的时候，不需要修改其他类，采用面向接口的编程，其类图如下图所示：

根据以上类图，你需要设计和编写如下类： ######1.IGeometry接口类 ，里面有double getArea()接口方法 2.Rect类实现接口，有属性 a,b,有参构造方法及对接口方法的实现 ######3.Circle类实现接口，有属性r，有参构造方法及对接口方法的实现，其中PI=3.14 4.TotalArea类完成对不同形状图形面积求和，有属性IGeometry[] tuxing 数组用来存储 不同形状图形对象，SetTuxing(IGeometry[] t) 给属性tuxing赋值，double computeTotalArea()方法用来计算tuxing数组中存放的图形的面积和，并返回面积和。

主类已经给出，请结合主类完成上面类的编写

裁判测试程序主类：

public class Main {

    public static void main(String[] args) {
         IGeometry [] tuxing=new IGeometry[29]; //有29个Geometry对象
          for(int i=0;i<tuxing.length;i++) {   //29个Geometry对象分成两类
              if(i%2==0)
                  tuxing[i]=new Rect(16+i,68);
              else if(i%2==1)
                  tuxing[i]=new Circle(10+i);
          } 
          TotalArea computer=new TotalArea();
          computer.setTuxing(tuxing);  
          System.out.printf("各种图形的面积之和:\n%.2f",computer.computerTotalArea());

    }
}

/* 请在这里填写答案  请结合主类代码，在代码框完成IGeometry接口类，Rect类，Circle类和TotalArea类*/

输入样例：

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

无

输出样例：

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

各种图形的面积之和:
58778.36

interface IGeometry{
    
    double getArea();
}
class Rect implements IGeometry{
    double a,b;
    public double getArea() {
        return a*b;
    };
    Rect(double a,double b)
    {
        this.a=a;
        this.b=b;
    }
}
class Circle implements IGeometry{
    double r;
    public double getArea() {
        return 3.14*r*r;
    };
    Circle(double r){
        this.r=r;
    }
}
class  TotalArea {
    IGeometry[] tuxing;
    void setTuxing(IGeometry[] t) {
        this.tuxing=t;
    }
    public double computerTotalArea() {
        double s=0;
    for(int i=0;i<tuxing.length;i++)
    {
        s=s+tuxing[i].getArea();
    }
    return  s ;
    }
    
}

十二、图书和音像租赁 

图书和音像店提供出租服务，包括图书和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{
    abstract double getDailyRent();
}

class Book extends Media{
    String name;
    double price;
    
    public Book(String name,double price) {
        this.name=name;
        this.price=price;
    }
    
    public double getDailyRent() {
        return this.price*0.01;
    }
}

class DVD extends Media{
    String name;
    
    public DVD(String name) {
        this.name=name;
    }
    
    public double getDailyRent() {
        return 1;
    }
}

class MediaShop{

    public static double calculateRent(Media[] medias, int days) {
        double sum=0;
        for(Media m:medias) {
            if(m instanceof DVD) {
                DVD d=(DVD)m;
                sum+=d.getDailyRent()*days;
            }else if(m instanceof Book) {
                Book b=(Book)m;
                sum+=b.getDailyRent()*days;
            }
        }
        return sum;
    }
}

二、编程题

一、覆盖

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

###1. 新建PersonOverride类

a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。

b. 有参构造函数，参数为name, age, gender

c. 无参构造函数，使用this(name, age,gender)调用有参构造函数。参数值分别为"default",1,true

d.toString()方法返回格式为：name-age-gender

e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.

###2. main方法 2.1 输入n1，使用无参构造函数创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造函数。

提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。

输入样例:

1

3 zhang 10 true zhang 10 true zhang 10 false

输出样例:

default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner se=new Scanner (System.in);
        int n1=se.nextInt();
        PersonOverride persons1[] =new PersonOverride[n1];
        for(int i=0;i<n1;i++) {
            persons1[i]=new PersonOverride();
            System.out.println(persons1[i].toString());
        }
        int n2=se.nextInt();
        ArrayList<PersonOverride> persons2=new ArrayList<PersonOverride>();
        for(int i=0;i<n2;i++) {
            PersonOverride a=new PersonOverride(se.next(),se.nextInt(),se.nextBoolean());
            if(!persons2.contains(a)) {
                persons2.add(a);
                System.out.println(a.toString());
            }
        }
        System.out.println(persons2.size());
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

class PersonOverride {
    private String name;
    private int age;
    private boolean gender;
  public PersonOverride() {
        this.name = "default";
        this.age = 1;
        this.gender = true;
    }
    public PersonOverride(String name, int age, boolean gender) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
    @Override
    public String toString() {
        return  name + "-" + age + "-" + gender;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + (gender ? 1231 : 1237);
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PersonOverride other = (PersonOverride) obj;
        if (age != other.age)
            return false;
        if (gender != other.gender)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public boolean isGender() {
        return gender;
    }
    public void setGender(boolean gender) {
        this.gender = gender;
    }
}

二、接口-Comparator

Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。

#1.编写PersonSortable2类 属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString方法：返回格式name-age

#2 编写Comparator类

1. 编写NameComparator类，实现对name进行升序排序
2. 编写AgeComparator类，对age进行升序排序

#3.main方法中

1. 输入n
2. 输入n行name age，并创建n个对象放入数组
3. 对数组按照name进行升序排序后输出。
4. 在3的基础上对数组按照age进行升序排序后输出。
5. 最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。

System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));

输入样例:

5
zhang 15
zhang 12
wang 14
Wang 17
li 17

输出样例:

NameComparator:sort
Wang-17
li-17
wang-14
zhang-15
zhang-12
AgeComparator:sort
zhang-12
wang-14
zhang-15
Wang-17
li-17
//最后两行是标识信息

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

class PersonSortable2{
    private String name;
    private int age;
    
    public PersonSortable2(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public String toString(){
        return this.name + "-" + this.age;
    }
}

class NameComparator implements Comparator<PersonSortable2>{

    @Override
    public int compare(PersonSortable2 o1, PersonSortable2 o2) {

        return o1.getName().compareTo(o2.getName());
    }
}

class AgeComparator implements Comparator<Object>{

    @Override
    public int compare(Object o1, Object o2) {
        // TODO Auto-generated method stub
        return ((PersonSortable2)o1).getAge() - ((PersonSortable2)o2).getAge();
    }
    
}

public class Main {
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        
        int n = cin.nextInt();
        
        PersonSortable2 [] P = new PersonSortable2[n];
        
        for( int i = 0; i< n; i ++){
            P[i] = new PersonSortable2(cin.next(), cin.nextInt());
        }
        
        Arrays.sort(P, (new NameComparator()));
        System.out.println("NameComparator:sort");
        for(int i = 0; i < n; i ++){
            System.out.println(P[i]);
        }
        Arrays.sort(P, (new AgeComparator()));
        System.out.println("AgeComparator:sort");
        for(int i = 0; i < n; i ++){
            System.out.println(P[i]);
        }
        System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
        System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
    
        cin.close();
    }
}

三、集体评分 

程序填空题。请补充以下代码，完成题目要求。（注意：需要提交完整代码） 有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
abstract class RR{
   int[] grade;
   public RR(int[] grade){
      this.grade = grade;
   }
   public abstract double mark();
}
class RT extends RR{

}

输入格式:

在一行中给出5个不超过10的正整数（从小到大排列）。

输出格式:

输出集体评分，保留小数点后两位。

输入样例:

1 2 4 6 9

输出样例:

4.00

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
interface RR{
   double mark();
}
class RT implements RR{
   int[] grade;
   public RT(int[] grade){
      this.grade = grade;
   }
 public double mark()
   {
       return (grade[1]+grade[2]+grade[3])/3;
   }
}

四、集体评分2

 程序填空题。请补充以下代码，完成题目要求。（注意：需要提交完整代码） 有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
interface RR{
   double mark();
}
class RT implements RR{
   int[] grade;
   public RT(int[] grade){
      this.grade = grade;
   }
}

输入格式:

在一行中给出5个不超过10的正整数（从小到大排列）。

输出格式:

输出集体评分，保留小数点后两位。

输入样例:

1 2 4 6 9

输出样例:

4.00

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
interface RR{
   double mark();
}
class RT implements RR{
   int[] grade;
   public RT(int[] grade){
      this.grade = grade;
   }
 public double mark()
   {
       return (grade[1]+grade[2]+grade[3])/3;
   }
}

五、职工排序题

1． 为某保险公司设计一个职工管理系统，其中职工类的属性有：职工编号，姓名，性别，团体险业绩，个体险业绩；方法有： 每个属性对应的set，get方法； 不带参数的构造方法； 带参数的构造方法，完成对职工属性的初始化； 该类实现接口Comparable，完成对职工总业绩的比较。

2． 设计一个类，实现Comparator接口，完成对团体险业绩的比较；

3． 在Main类中，创建一个职工的线性表，分别完成对职工线性表按照总业绩升序排序，按照团体险业绩升序排序。 注意：不要设计键盘输入职工信息，可根据样例中提供的数据直接创建职工对象；

输入格式:

输出格式:

各项之间用逗号“,”分隔

输入样例:

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

无

输出样例:

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

编号,团险,个险,姓名,性别
1,500,400,职工1,female
3,600,300,职工3,male
2,400,600,职工2,female
4,800,200,职工4,female
5,500,700,职工5,male
编号,团险,个险,姓名,性别
2,400,600,职工2,female
1,500,400,职工1,female
5,500,700,职工5,male
3,600,300,职工3,male
4,800,200,职工4,female

import java.util.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Scanner sc = new Scanner(System.in);
        List<Staff> ss=new ArrayList<Staff>();
        ss.add(new Staff(1,500,400,"职工1","female"));
        ss.add(new Staff(2,400,600,"职工2","female"));
        ss.add(new Staff(3,600,300,"职工3","male"));
        ss.add(new Staff(4,800,200,"职工4","female"));
        ss.add(new Staff(5,500,700,"职工5","male"));

        Collections.sort(ss);
        System.out.println("编号,团险,个险,姓名,性别");
        for (Staff s:ss){
            System.out.println(s.toString());
        }
        ss.sort(new newComparetor());
        System.out.println("编号,团险,个险,姓名,性别");
        for (Staff s:ss){
            System.out.println(s.toString());
        }


    }
}

class Staff implements Comparable<Staff>{
    private int number;
    private int tscore;
    private int pscore;
    private String name ;
    private String sex;

    public Staff() {
    }

    public Staff(int number, int tscore, int pscore, String name, String sex) {
        this.number = number;
        this.tscore = tscore;
        this.pscore = pscore;
        this.name = name;
        this.sex = sex;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    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 int getTscore() {
        return tscore;
    }

    public void setTscore(int tscore) {
        this.tscore = tscore;
    }

    public int getPscore() {
        return pscore;
    }

    public void setPscore(int pscore) {
        this.pscore = pscore;
    }

    @Override
    public int compareTo(Staff s) {
        int ret=this.pscore+this.tscore-s.getPscore()-s.getTscore();
        if (ret>0)ret=1;
        else if (ret<0)ret=-1;
        return ret;
    }

    @Override
    public String toString() {
        return number +
                "," + tscore +
                "," + pscore +
                "," + name +
                "," + sex;
    }
}

class newComparetor implements Comparator<Staff> {
    public newComparetor() {
    }

    @Override
    public int compare(Staff o1, Staff o2) {
        int ret=o1.getTscore()-o2.getTscore();
        if (ret>0)ret=1;
        else if (ret<0)ret=-1;
        return ret;
    }
}

六、程序改错题

程序改错题。以下代码存在错误，请修改后提交。

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.shout();
        animal.run();
    }
}

class Animal {
    void shout() {
        System.out.println("animal shout！");
    }
}

class Dog extends Animal {
    void shout() {
        super.shout();
        System.out.println("wangwang……");
    }

    void run() {
        System.out.println("Dog is running");
    }
}

输入样例:

无

输出样例:

animal shout！
wangwang……
Dog is running

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Dog a=(Dog)animal;
        a.shout();
        a.run();
    }
}

class Animal {
    void shout() {
        System.out.println("animal shout！");
    }
}

class Dog extends Animal {
    void shout() {
        super.shout();
        System.out.println("wangwang……");
    }

    void run() {
        System.out.println("Dog is running");
    }
}