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表示普通账户对象，包含以下成员

①属性：

②方法：

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

①属性：

②方法：

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

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

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

裁判测试程序样例：

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型，表示票号；
②方法：

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

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

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

裁判测试程序样例：

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;
}
}