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

### 回答1：
容器container接口的定义：

interface Container {
double getSurfaceArea(); // 求表面积的方法
double getVolume(); // 求体积的方法
}

容器类层次结构的模拟实现：

抽象类AbstractContainer实现Container接口，并定义了一个抽象方法getName()，用于获取容器的名称。

public abstract class AbstractContainer implements Container {
public abstract String getName(); // 获取容器名称的抽象方法
}

具体容器类Cylinder、Cube、Sphere继承AbstractContainer，并实现getName()方法和重写getSurfaceArea()、getVolume()方法。

public class Cylinder extends AbstractContainer {
private double radius;
private double height;

public Cylinder(double radius, double height) {
this.radius = radius;
this.height = height;
}

@Override
public String getName() {
return "圆柱体";
}

@Override
public double getSurfaceArea() {
return 2 * Math.PI * radius * (radius + height);
}

@Override
public double getVolume() {
return Math.PI * radius * radius * height;
}
}

public class Cube extends AbstractContainer {
private double sideLength;

public Cube(double sideLength) {
this.sideLength = sideLength;
}

@Override
public String getName() {
return "正方体";
}

@Override
public double getSurfaceArea() {
return 6 * sideLength * sideLength;
}

@Override
public double getVolume() {
return sideLength * sideLength * sideLength;
}
}

public class Sphere extends AbstractContainer {
private double radius;

public Sphere(double radius) {
this.radius = radius;
}

@Override
public String getName() {
return "球体";
}

@Override
public double getSurfaceArea() {
return 4 * Math.PI * radius * radius;
}

@Override
public double getVolume() {
return 4 / 3. * Math.PI * radius * radius * radius;
}
}

多态机制测试：

在主函数中，创建一个AbstractContainer类型的数组，分别用Cylinder、Cube、Sphere实例化数组元素，然后遍历数组，调用每个元素的getName()、getSurfaceArea()、getVolume()方法，输出容器名称、表面积、体积。

public static void main(String[] args) {
AbstractContainer[] containers = new AbstractContainer[3];
containers[] = new Cylinder(2, 5);
containers[1] = new Cube(3);
containers[2] = new Sphere(4);

for (AbstractContainer container : containers) {
System.out.println(container.getName() + "的表面积为：" + container.getSurfaceArea() + "，体积为：" + container.getVolume());
}
}

输出结果：

圆柱体的表面积为：94.24777960769379，体积为：62.83185307179586
正方体的表面积为：54.，体积为：27.
球体的表面积为：201.06192982974676，体积为：268.082573106329

### 回答2：
容器（container）是一种可以存储和搬运物品的物品，它们通常是中空的，具有一定的尺寸和形状，可以将其他物品放置其中。在软件开发中，“容器”是指一种数据结构，用来存储和操作多个元素。

容器的接口定义包括以下几个方法：

1. add(Object obj): 向容器中添加一个元素。
2. remove(Object obj): 从容器中删除一个元素。
3. size(): 返回容器中元素的数量。
4. clear(): 清空容器中所有元素。
5. contains(Object obj): 判断容器中是否包含某个元素。

一个容器类层次结构可以包含多个不同的容器类，这些类可以继承自一个基类或接口。例如，可以定义一个基本的容器接口 Container，然后定义多个具体的容器类，如 ArrayList、LinkedList 和 HashSet 等。这些容器类可以实现 Container 接口，并重写其抽象方法，以实现特定的功能。

下面是一个 Container 接口的定义：

public interface Container {
void add(Object obj);
void remove(Object obj);
int size();
void clear();
boolean contains(Object obj);
double getSurfaceArea();
double getVolume();
}

其中，getSurfaceArea() 方法用于求容器的表面积，getVolume() 方法用于求容器的体积。这些方法的实现可以因容器类型的不同而有所不同。

下面是一个简单的容器类层次结构：

public abstract class AbstractContainer implements Container {
protected List<Object> elements = new ArrayList<Object>();

public void add(Object obj) {
elements.add(obj);
}

public void remove(Object obj) {
elements.remove(obj);
}

public int size() {
return elements.size();
}

public void clear() {
elements.clear();
}

public boolean contains(Object obj) {
return elements.contains(obj);
}

public abstract double getSurfaceArea();
public abstract double getVolume();
}

public class Box extends AbstractContainer {
private double length;
private double width;
private double height;

public Box(double length, double width, double height) {
this.length = length;
this.width = width;
this.height = height;
}

public double getSurfaceArea() {
return 2 * (length * width + length * height + width * height);
}

public double getVolume() {
return length * width * height;
}
}

public class Cylinder extends AbstractContainer {
private double radius;
private double height;

public Cylinder(double radius, double height) {
this.radius = radius;
this.height = height;
}

public double getSurfaceArea() {
return 2 * Math.PI * radius * height + 2 * Math.PI * radius * radius;
}

public double getVolume() {
return Math.PI * radius * radius * height;
}
}

在上述容器类层次结构中，AbstractContainer 类实现了 Container 接口，并提供了一个默认的实现。Box 类继承 AbstractContainer 类，并实现了 getSurfaceArea() 和 getVolume() 方法，用于求矩形盒子的表面积和体积。Cylinder 类也继承 AbstractContainer 类，并实现了 getSurfaceArea() 和 getVolume() 方法，用于求圆柱体的表面积和体积。

下面是一个使用多态机制测试容器类层次结构的示例：

public class TestContainer {
public static void main(String[] args) {
List<Container> containers = new ArrayList<Container>();
containers.add(new Box(2, 3, 4));
containers.add(new Cylinder(2, 4));

for (Container container : containers) {
System.out.println("Surface Area: " + container.getSurfaceArea());
System.out.println("Volume: " + container.getVolume());
System.out.println();
}
}
}

在上述代码中，首先创建了一个 container 的 List 集合，将一个 Box 对象和一个 Cylinder 对象添加到容器中。然后通过 foreach 循环遍历容器中的每一个 Container 类型的对象，并分别打印出它们的表面积和体积。由于 Box 和 Cylinder 类都实现了 Container 接口，并重写了 getSurfaceArea() 和 getVolume() 方法，因此程序可以正确计算出它们的表面积和体积，这就体现了多态的机制。

### 回答3：
容器是一种能够存储元素的封装物，它可以对于元素进行增删改查等操作。在面向对象的编程语言中，一般可以通过定义一个容器接口来表现容器的能力、特性等，然后再实现不同类型的容器类，每种类都通过继承容器接口并实现其方法来达到对容器的描述和操作。

定义容器接口Container：

public interface Container {
    void add(Object obj);
    void remove(Object obj);
    boolean contains(Object obj);
    int size();
}

在这个接口中，我们定义了四个方法：

- add：向容器中添加元素obj
- remove：从容器中移除元素obj
- contains：判断容器中是否包含元素obj
- size：获取容器中元素的数量

对于这四个方法的具体实现，可以在不同的容器类中实现。

接下来，我们可以设计一个容器类层次结构，并在其中实现这个接口。一个简单的容器类层次结构示例如下：

public abstract class AbstractContainer implements Container {
    // 实现 Container 接口中的方法
    //...
}

public class ListContainer extends AbstractContainer {
    // 实现 List 容器类的特有方法
    //...
}

public class StackContainer extends AbstractContainer {
    // 实现 Stack 容器类的特有方法
    //...
}

public class QueueContainer extends AbstractContainer {
    // 实现 Queue 容器类的特有方法
    //...
}

// 定义求表面积和体积的方法
public interface CalculateVolume {
    double getArea();
    double getVolume();
}

// 继承 AbstractContainer 类并实现 CalculateVolume 接口，实现求表面积和体积的方法
public class BoxContainer extends AbstractContainer implements CalculateVolume {
    @Override
    public void add(Object obj) {
        // 在 BoxContainer 中实现添加元素方法，具体实现可以参照 StackContainer 或 ListContainer
    }

    @Override
    public void remove(Object obj) {
        // 在 BoxContainer 中实现移除元素方法，具体实现可以参照 StackContainer 或 ListContainer
    }

    @Override
    public boolean contains(Object obj) {
        // 在 BoxContainer 中实现判断元素是否存在方法，具体实现可以参照 StackContainer 或 ListContainer
        return false;
    }

    @Override
    public int size() {
        // 在 BoxContainer 中实现获取容器大小方法，具体实现可以参照 StackContainer 或 ListContainer
        return 0;
    }

    @Override
    public double getArea() {
        // 获取 Box 容器的表面积，具体实现可以参照 Box 容器的定义和计算公式
        return 0;
    }

    @Override
    public double getVolume() {
        // 获取 Box 容器的体积，具体实现可以参照 Box 容器的定义和计算公式
        return 0;
    }
}

在上面的代码中，我们首先定义了一个 CalculateVolume 接口，其中包含了求表面积和体积的方法，然后让 BoxContainer 类继承 AbstractContainer 类和 CalculateVolume 接口，实现了其中所有的抽象方法。

这时候，我们就可以利用多态机制，通过指向不同类型的容器对象的指针来调用相应的方法。比如我们可以创建一个 BoxContainer 对象并调用它的 add、remove、size、getArea、getVolume 方法：

BoxContainer box = new BoxContainer();
box.add("Hello World");
box.remove("Hello World");
int size = box.size();
double area = box.getArea();
double volume = box.getVolume();

通过上述代码，我们即可得到 BoxContainer 容器对象的大小、表面积和体积等信息。此外，我们也可以结合其他容器类中实现的方法，比如 StackContainer 和 QueueContainer 中的 push、pop、peek 等操作，进行更多不同的数据处理和交互。