多态应用:计算面积

定义三个类,父类(抽象类)GeometricObject代表几何形状,子类Circle代表圆形,子类Rectangle代表矩形。具体属性和方法如下:
父类 (抽象类)GeometricObject
属性:private String color; private String name;
为上述变量提供getter()和setter()方法
构造方法:为color和name初始化
public GeometricObject(String color, String name)
抽象方法:
public double findArea();用于计算几何图形的面积

子类:Circle
属性:private double radius;
为上述变量提供getter()和setter()方法
构造方法:
设计构造方法为圆形的name,color和radius初始化
方法:
实现findArea()方法用于计算圆形的面积并返回计算结果

子类:Rectangle
属性:private double width; private double height;
为上述变量提供getter()和setter()方法
构造方法:
设计构造方法为圆形的name,color,width和height初始化
方法:
实现findArea()方法用于计算矩形的面积并返回计算结果

测试类Main
方法:
public static void main(String[] args) {

    String shape;
    String color;
    double r,w,h;
    //System.out.println("input color,shape:");
    Scanner sc=new Scanner(System.in);
    color=sc.nextLine();
    shape=sc.nextLine();
    GeometricObject g=null;
    //输入颜色、形状,根据形状的不同 再输入半径或宽高、创建不同的对象,计算面积及输出
    /*  */
  }
public static void show(GeometricObject g){//该函数的方法体固定如下:
    System.out.println(g.getName()+"的颜色是:"+g.getColor()+",面积是:"+g.findArea());
}

注意:须书写抽象类GeometricObject、子类Circle和Rectangle。

输入格式:

蓝色

圆形

3.4

输出格式:

圆形的颜色是:蓝色,面积是:36.31681107549801

输入样例:

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

红色
矩形
1 2

输出样例:

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

矩形的颜色是:红色,面积是:2.0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

答案

import java.util.Scanner;
import static java.lang.Math.PI;
public class Main {
    public static void main(String[] args) {
        String shape;
        String color;
        double r,w,h;
        Scanner sc=new Scanner(System.in);
        color=sc.nextLine();
        shape=sc.nextLine();
        GeometricObject g=null;
        if(shape.equals("圆形"))
        {
            r=sc.nextDouble();
            Circle c=new Circle(color,"圆形",r);
            show(c);
        }
        else {
            w=sc.nextDouble();
            h=sc.nextDouble();
             Rectangle rc=new Rectangle(color,"矩形",w,h);
            show(rc);
        }
    }
    public static void show(GeometricObject g){//该函数的方法体固定如下:
        System.out.println(g.getName()+"的颜色是:"+g.getColor()+",面积是:"+g.findArea());
    }
}
 abstract class GeometricObject
{
   public abstract String getName();
    public abstract String getColor();
    public abstract double findArea();

}
 class Circle extends GeometricObject
 {
    String color,name;
    double r;
     public Circle(String color, String name,double r) {
       this.color=color;
       this.name=name;
       this.r=r;
     }
     public String getName() {
         return name;
     }
     public String getColor() {
         return color;
     }
     public double findArea() {
         return r*r*PI;
     }
 }
 class Rectangle extends GeometricObject {
    String color,name;
    double w,h;
     public Rectangle(String color, String name,double w,double h) {
         this.color=color;
         this.h=h;
         this.w=w;
         this.name=name;
     }
     public String getName() {
         return name;
     }
     public String getColor() {
         return color;
     }
     public double findArea() {
         return w*h;
     }
 }

  • 17
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答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 等操作,进行更多不同的数据处理和交互。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小白宇航(互关版)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值