sdut-Java面向对象-06 继承和多态、抽象类和接口（函数题：10-18题）

6-10 设计一个Triangle类继承自GeometricObject类

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

■ 三个名为side1、side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0。

■ 一个无参构造方法创建默认的三角形。

■ 一个能创建带制定side1、side2和side3的三角形的构造方法。

■ 所有三个数据域的访问器方法。

■ 一个名为getArea()的方法返回这个三角形的面积。

■ 一个名为getPerimeter()的方法返回这个三角形的周长。

■ 一个名为toString()的方法返回这个三角形的字符串描述。

toString()方法的实现如下所示：

return "Triangle: side1 = " + side1 + " side2 = " + side2 +" side3 = " + side3;

编写一个测试程序，提示用户输入三角形的三条边、颜色以及一个Boolean值表明该三角形是否填充。程序应该使用输入创建一个具有这些边并设置color和filled属性的三角形。程序应该显示面积、周长以及边长。

系统会自动提交Main类和GeometricObject类。

类的定义：

设计一个Triangle类继承GeometricObject。例如：
class Triangle extends GeometricObject{  }

裁判测试程序样例：

//Main测试类
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;
    }
    

    @Override
    public String toString() {
        return "created on " + dateCreated + "\ncolor: " + color + "and filled: " + filled;
    }

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

输入样例：

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

3 4 5
red
true

输出样例：

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

The area is 6.0
The perimeter is 12.0
Triangle: side1=3.0 side2=4.0 side3=5.0

实现代码：

class Triangle extends GeometricObject{
    double side1;
    double side2;
    double side3;

    public Triangle() {
        side1=1.0;
        side2=1.0;
        side3=1.0;
    }

    public Triangle(double side1, double side2, double side3) {
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    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;
    }
    public double getArea(){
        double p=(side1+side2+side3)/2.0;
        return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
    }
    public double getPerimeter(){
        return side1+side2+side3;
    }
    public String toString(){
        return "Triangle: side1=" + side1 + " side2=" + side2 +" side3=" + side3;
    }
}

6-11 普通账户和支票账户

编写一个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"

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

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

1. 使用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{
private int id;
private int balance;
public Account() {
}
public Account(int id, int balance) {
this.id = id;
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
public boolean withdraw(int money)
{
int tmp=balance-money;
if(tmp>=0)
setBalance(tmp);
return tmp>=0;
}
public void deposit(int money)
{
balance+=money;
}
public String toString()
{
return "The balance of account "+id+" is "+balance;
}
}
class CheckingAccount extends Account{
private int overdraft;
public CheckingAccount() {
}
public CheckingAccount(int id, int balance, int overdraft) {
super(id, balance);
this.overdraft = overdraft;
}
    @Override
public boolean withdraw(int money) {
int tmp=getBalance()+overdraft-money;
if(tmp>=0)
setBalance(getBalance()-money);
return tmp>=0;
}
}

6-12 设计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 rate;
public Worker(String name, double rate) {
this.name = name;
this.rate = rate;
}
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
public void pay(int hour)
{
System.out.println("Not Implemented");
}
}
class HourlyWorker extends Worker{
public HourlyWorker(String name, double rate) {
super(name, rate);
}
public void pay(int hour)
{
if(hour>40){
System.out.println(rate*40+(hour-40)*2*rate);
}
else
System.out.println(1.0*hour*rate);
}
}
class SalariedWorker extends Worker{
public SalariedWorker(String name, double hourSalary) {
super(name, hourSalary);
}
public void pay(int hour)
{
pay();
}
public void pay()
{
System.out.println(40.0*rate);
}
}

6-13 图书和音像租赁

图书和音像店提供出租服务，包括图书和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

实现代码：

class Media{
String name;
public double getDailyRent(){
return 0.0;
}
}
class Book extends Media{
double price;
public Book(String name,double price)
{
this.name=name;
this.price=price;
}
public double getDailyRent(){
return 0.01*price;
}
}
class DVD extends Media{
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(int i=0;i<medias.length;i++)
{
sum+=medias[i].getDailyRent()*days;
}
return sum;
}
}

6-14 使用继承，实现"剪刀石头布的游戏"

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

小时候很喜欢玩一个游戏，"剪刀石头布"，可以是出拳的形式，或跳格子的形式。现在我们用计算机来玩这个游戏。
电脑用随机数产生剪刀石头布，游戏玩家用输入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);//子类的构造方法必须调用父类的构造方法，使用super关键字；使用super关键字的这行语句必须放在子类的第一行
    }
}

class PersonPlayer extends Player{
    PersonPlayer(String name) {
        super(name);
    }
    int choice(){
        Scanner scan=new Scanner(System.in);
        int c=scan.nextInt();
        return c;
    }
}

class Game{
    ComputerPlayer cp;
    PersonPlayer pp;
    public Game(ComputerPlayer cp, PersonPlayer pp) {
        this.cp = cp;//切忌写成cp=cp
        this.pp = pp;
    }
    //如果刚开始不习惯用this，可以用下面替代
    //public Game(ComputerPlayer x, PersonPlayer y) {
    //    x = cp;//切忌写成cp=cp
    //    y = pp;
  //  }
 
    void start(){
        int c=cp.show(),p=pp.choice();
        if (c==p)
            System.out.print("A Draw.");
        else if (c==1&&p==3)
            System.out.print("Winner is computerPlayer.");
        else if (p==1&&c==3)
            System.out.print("Winner is personPlayer.");
        else if (p<c)
            System.out.print("Winner is computerPlayer.");
        else  System.out.print("Winner is personPlayer.");
    }
}

6-15 教师、学生排序

已知Main类、Person类的设计，完成Student类，Teacher类、MyTool类的设计。

函数接口定义：

class Student extends Person{ }
class Teacher extends Person{ }
class MyTool{ public static void separateStu_T(List persons,List teachers,List students){}   }

Student类继承了Person，拥有私有属性int类型的sno和String类型的major，分别代表学号与所学专业；提供对应的set，get方法；比较方法完成按照学号比较。

Teacher类继承了Person，拥有私有属性int类型的tno和String类型的subject，分别代表教师编号与所授科目；提供对应的set，get方法；比较方法完成按年龄比较。

MyTool类中提供方法public static void separateStu_T(List persons,List teachers,List students){}，方法 separateStu_T的功能是将persons线性表中的 teacher，student分别放到teachers,students两个线性表中。

裁判测试程序样例：

import java.util.*;

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

     List persons=getPersons();  //得到一个所有人的线性表
        
        List teachers=new ArrayList();
        List students=new ArrayList();
    
        MyTool.separateStu_T( persons,teachers,students); //将persons线性表中的 teacher，student分别放到teachers,students两个线性表中
        
        Collections.sort(teachers);  //对教师线性表排序
        Collections.sort(students);  //对学生线性表排序
        
        showResult(teachers);  //显示教师线性表排序以后的结果
        showResult(students);  //显示学生线性表排序以后的结果
        
    }
    
    public static List getPersons()
    {
        List persons=new ArrayList();
        
        Scanner in=new Scanner(System.in);
        Person person=null;
        
        int num=Integer.parseInt(in.nextLine());
        
        for(int i=0;i<num;i++)
        {    String str=in.nextLine();
            String []data=str.split(",");
            
            if(data[0].equalsIgnoreCase("student"))
                 person=new Student(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
            else if (data[0].equalsIgnoreCase("teacher"))
                  person=new Teacher(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
            else person=null;
                 persons.add(person);
        }
        return persons;
    }
    
    public static void showResult(List persons)
    {
        for(int i=0;i<persons.size();i++)
        {
            Person per=(Person)persons.get(i);
            System.out.println(per.getName()+","+per.getGender()+","+per.getAge());
        }
    }
    
    
}    



abstract class Person  implements Comparable
{    private String name;
     private String gender;
     private int age;
     
    
    public String getName() {
        return name;
    }


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


    public String getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, String gender, int age) {
        super();
        this.name = name;
        this.gender = gender;
        this.age = age;
    }


}

/* 请在这里写你的代码 */

输入样例：

输入的第一行是总人数n，紧跟着输入n行，每一行代表一个人的信息。下面的例子中n=5，输入了5个人的信息。

5
student,1001,Tom1,female,18,computer
teacher,2001,Jake1,female,35,datastructer
student,1002,Tom2,male,19,computer
student,1003,Tom3,female,20,software
teacher,2002,Jake2,female,33,database

输出样例：

注意：本样例输出结果中两名教师是按照年龄升序排序的，三名学生是按照学号降序排序的。

Jake2,female,33
Jake1,female,35
Tom3,female,20
Tom2,male,19
Tom1,female,18

实现代码：

class Student extends Person{
private int sno;
private String major;
public Student(int sno, String name, String gender, int age, String major) {
super(name, gender, age);
this.sno = sno;
this.major = major;
}
public int getSno() {
return sno;
}
public void setSno(int sno) {
this.sno = sno;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public int compareTo(Object o) {
Student temp = (Student)o;
if (this.sno < temp.sno){
return 1;
}
if (this.sno == temp.sno){
return 0;
}
return -1;
}
}
class Teacher extends Person{
private int tno;
private String subject;
public Teacher(int tno, String name, String gender, int age, String subject) {
super(name, gender, age);
this.tno = tno;
this.subject = subject;
}
public int getTno() {
return tno;
}
public void setTno(int tno) {
this.tno = tno;
}public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
@Override
public int compareTo(Object o) {
Teacher temp = (Teacher)o;
if (this.getAge() > temp.getAge()){
return 1;
}
if (this.getAge() == temp.getAge()){
return 0;
}
return -1;
}
}
class MyTool{
public static void separateStu_T(List persons,List teachers,List students){
for (int i = 0; i < persons.size(); i++){
if (persons.get(i) instanceof Student){
students.add(persons.get(i));
}
if (persons.get(i) instanceof Teacher){
teachers.add(persons.get(i));
}
}
}
}

6-16 设计门票（抽象类）

某学校举办一次活动，需要凭票参加，每张票都有票号和售价。

门票分为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 {
int number;
public Ticket(int number) {
this.number=number;
}
abstract public int getPrice();
abstract public String toString();
}
class WalkupTicket extends Ticket {
int price;
public WalkupTicket(int number) {
super(number);
this.price=50;
}
public int getPrice() {
return this.price;
}
public String toString() {
return "Number:"+this.number+",Price:"+this.price;
}
}
class AdvanceTicket extends Ticket {
int leadTime;
int price;
public AdvanceTicket(int number,int leadTime) {
super(number);
this.leadTime=leadTime;
if(leadTime>10)this.price=30;
else this.price=40;
}
public int getPrice() {
return this.price;
}
public String toString() {
return "Number:"+this.number+",Price:"+this.price;
    }
}
class StudentAdvanceTicket extends AdvanceTicket {
int height;
int price;
public StudentAdvanceTicket(int number,int leadTime,int height) {
super(number,leadTime);
this.height=height;
if(height>120) {
if(leadTime>10)this.price=20;
else this.price=30;
}else {
if(leadTime>10)this.price=10;
else this.price=15;
}
}
public int getPrice() {
return this.price;
}
public String toString() {
return "Number:"+this.number+",Price:"+this.price;
}
}

6-17 可比较的几何类（抽象类与接口）

通过继承和多态的学习，同学们熟悉了GeometricObject类，现在用抽象类的观点，修改GeometricObject类以实现Comparable接口，且在GeometricObject类中定义一个静态方法：求两个GeometricObject对象中较大者。

此题提交时将会附加下述代码到被提交的Java程序末尾。

裁判测试程序样例：

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

        Circle circle1 = new Circle(input.nextInt());
        Circle circle2 = new Circle(input.nextInt());

        Circle circle = (Circle) GeometricObject.max(circle1, circle2);
        System.out.println("The max circle's radius is " + circle.getRadius());
        System.out.println(circle);
    }
}

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

输入样例：

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

4 10

输出样例：

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

The max circle's radius is 10.0
Circle radius = 10.0

实现代码：

class Circle implements GeometricObject
{
public double getRadius()
{
return radius;
}
public String toString()
{
return "Circle radius = "+radius;
}
double radius;
Circle(int radius)
{
this.radius=(double) radius;
}
}
interface GeometricObject
{
static Circle max(Circle c1, Circle c2)
{
if(c1.radius>=c2.radius)
{
return c1;
}else return c2;
}
}

6-18 面积求和

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

根据以上类图，你需要设计和编写如下类：

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 {
public double getArea();
}
class Rect implements IGeometry {
public double a;
public double b;
public Rect(double a, double b) {
super();
this.a = a;
this.b = b;
}
public double getArea() {
return a * b;
}
}
class Circle implements IGeometry {
public double r;
public Circle(double r) {
super();
this.r = r;
}
public double getArea() {
return r * r * 3.14;
}
}
class TotalArea {
public IGeometry[] tuxing;
public void setTuxing(IGeometry[] t) {
this.tuxing = t;
}
public double computerTotalArea() {
double sum = 0.0;
for (IGeometry i : tuxing) {
sum += i.getArea();
}
return sum;
}
}