7-5 多态测试

定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。

1. 定义接口Container：
   属性：
   public static final double pi=3.1415926;
   抽象方法:
   public abstract double area();
   public abstract double volume();
   static double sumofArea(Container c[]);
   static double sumofVolume(Container c[]);
   其中两个静态方法分别计算返回容器数组中所有对象的面积之和、周长之和；
2. 定义Cube类、Cylinder类均实现自Container接口。
   Cube类(属性：边长double类型)、Cylinder类(属性：底圆半径、高，double类型)。

输入格式:

第一行n表示对象个数，对象类型用cube、cylinder区分，cube表示立方体对象，后面输入边长，输入cylinder表示圆柱体对象，后面是底圆半径、高。

输出格式:

分别输出所有容器对象的表面积之和、体积之和，结果保留小数点后2位。

输入样例:

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

4
cube
15.7
cylinder
23.5 100
cube
46.8
cylinder
17.5 200

输出样例:

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

56771.13
472290.12

代码实现区： 

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String s;
        Container[] container = new Container[n];
        for (int i = 0; i < n; i++) {
            s = scanner.next();
 
            if (s.equals("cube")) {
                double length = scanner.nextDouble();
                container[i] = new Cube(length);
            } else if (s.equals("cylinder")) {
                double r, h;
                r = scanner.nextDouble();
                h = scanner.nextDouble();
                container[i] = new Cylinder(r, h);
            }
        }
        System.out.printf("%.2f%n", Container.sumofArea(container));
        System.out.printf("%.2f%n", Container.sumofVolume(container));
    }
}
 
interface Container {
    public static final double pi = 3.1415926;
 
    public abstract double area();
 
    public abstract double volume();
 
    static double sumofArea(Container c[]) {
        double result = 0.0;
        for (int i = 0; i < c.length; i++) {
            result += c[i].area();
        }
        return result;
    }
 
    static double sumofVolume(Container c[]) {
        double result = 0.0;
        for (int i = 0; i < c.length; i++) {
            result += c[i].volume();
        }
        return result;
    }
}
 
class Cube implements Container {
    private double length;
 
    public Cube(double length) {
        this.length = length;
    }
 
    public Cube() {
    }
 
    public double getLength() {
        return length;
    }
 
    @Override
    public double area() {
        return getLength() * getLength() * 6;
    }
 
    @Override
    public double volume() {
        return getLength() * getLength() * getLength();
    }
}
 
class Cylinder implements Container {
 
    private double r;
    private double h;
 
    public Cylinder(double r, double h) {
        this.r = r;
        this.h = h;
    }
 
    public double getR() {
        return r;
    }
 
    public double getH() {
        return h;
    }
 
    @Override
    public double area() {
        return getR() * getR() * pi * 2 + getR() * 2 * pi * h;
    }
 
    @Override
    public double volume() {
        return getR() * getR() * pi * getH();
    }
}