设计一个名为Shape的类，一个float getArea(int r)方法，能够计算并返回半径为r的圆形面积；一个float getArea(int width, int height)方法，能够计算并返回一个宽度为width，高度为height的矩形面积（利用Math.PI获取π值）

以下是您所需要的Shape类的Java代码：

public class Shape {
    public float getArea(int r) {
        return (float) (Math.PI * r * r);
    }
    
    public float getArea(int width, int height) {
        return (float) (width * height);
    }
}

在这个类中，我们有两个方法，每个方法都可以计算不同形状的面积。第一个方法有一个整数参数r，它代表半径的长度，并利用了Math.PI获取π值来计算圆形面积。第二个方法有两个整数参数width和height，它代表矩形的宽和高，并返回矩形面积。

您可以像这样使用Shape类：

Shape shape = new Shape();
float circleArea = shape.getArea(5); // 计算半径为5的圆形面积
float rectangleArea = shape.getArea(4, 6); // 计算宽度为4，高度为6的矩形面积

相关问题

已定义一个shape抽象类，在此基础上派生出矩形Rectangle和圆形Circle类，二者都有GetArea( )函数计算对象的面积，并编写测试main( )函数。 Class Shape { Public: Shape(){} ~shape(){} Virtual float GetArea()=0; }

好的，你的要求是编写C语言的代码，下面是相应的实现：

#include <stdio.h>
#include <stdlib.h>

typedef struct Shape {
    float (*GetArea)(struct Shape* self);
} Shape;

typedef struct Rectangle {
    Shape shape;
    float width;
    float height;
} Rectangle;

typedef struct Circle {
    Shape shape;
    float radius;
} Circle;

float Rectangle_GetArea(Shape* self) {
    Rectangle* rect = (Rectangle*)self;
    return rect->width * rect->height;
}

float Circle_GetArea(Shape* self) {
    Circle* circle = (Circle*)self;
    return 3.14159 * circle->radius * circle->radius;
}

int main() {
    Shape* shapes[2];
    shapes[0] = (Shape*)malloc(sizeof(Rectangle));
    shapes[0]->GetArea = Rectangle_GetArea;
    ((Rectangle*)shapes[0])->width = 2.0;
    ((Rectangle*)shapes[0])->height = 3.0;

    shapes[1] = (Shape*)malloc(sizeof(Circle));
    shapes[1]->GetArea = Circle_GetArea;
    ((Circle*)shapes[1])->radius = 1.0;

    for (int i = 0; i < 2; i++) {
        printf("Shape %d area: %f\n", i, shapes[i]->GetArea(shapes[i]));
        free(shapes[i]);
    }

    return 0;
}

在这个代码中，我们首先使用 `typedef` 定义了 `Shape`、`Rectangle` 和 `Circle` 三个结构体类型。其中 `Shape` 结构体包含了一个函数指针 `GetArea`，用来计算对象的面积，它是一个虚函数（通过函数指针实现）。`Rectangle` 和 `Circle` 结构体分别包含了一个 `Shape` 类型的成员，用来支持多态性，以及各自的宽、高或半径等数据成员。

然后我们分别实现了 `Rectangle_GetArea()` 和 `Circle_GetArea()` 两个函数，它们分别用来计算矩形和圆形的面积。注意这两个函数的参数都是 `Shape*` 类型的指针，这样才能实现多态性。

在 `main()` 函数中，我们创建了一个 `Shape` 类型的指针数组，并分别用 `Rectangle` 和 `Circle` 的对象来初始化其中的元素。然后我们遍历这个数组，输出每个对象的面积，并释放掉动态分配的内存。

你可以将这个代码保存为一个名为 `shape.c` 的文件，然后在命令行中使用如下命令进行编译和运行：

gcc shape.c -o shape
./shape

然后你就可以看到输出结果了。

设计一个抽象类Shape，在此基础上派生出类Rectangle和类Circle，二者都具有计算对象面积的函数getArea（）以及计算对象周长的函数getPerim（）。

好的，根据您的要求，我为您编写了以下代码：

#include <iostream>
using namespace std;

// 抽象类 Shape
class Shape {
public:
    virtual float getArea() = 0; // 纯虚函数，用于计算面积
    virtual float getPerim() = 0; // 纯虚函数，用于计算周长
};

// 类 Rectangle，继承自 Shape
class Rectangle : public Shape {
public:
    Rectangle(float w, float h) : width(w), height(h) {} // 构造函数
    float getArea() { return width * height; } // 重写 Shape 类的纯虚函数，计算面积
    float getPerim() { return 2 * (width + height); } // 重写 Shape 类的纯虚函数，计算周长
private:
    float width; // 宽度
    float height; // 高度
};

// 类 Circle，继承自 Shape
class Circle : public Shape {
public:
    Circle(float r) : radius(r) {} // 构造函数
    float getArea() { return 3.14159 * radius * radius; } // 重写 Shape 类的纯虚函数，计算面积
    float getPerim() { return 2 * 3.14159 * radius; } // 重写 Shape 类的纯虚函数，计算周长
private:
    float radius; // 半径
};

int main() {
    // 创建 Rectangle 对象并计算面积和周长
    Rectangle rect(10, 5);
    cout << "Rectangle Area: " << rect.getArea() << endl;
    cout << "Rectangle Perimeter: " << rect.getPerim() << endl;

    // 创建 Circle 对象并计算面积和周长
    Circle cir(2.5);
    cout << "Circle Area: " << cir.getArea() << endl;
    cout << "Circle Perimeter: " << cir.getPerim() << endl;

    return 0;
}

在上述代码中，我先定义了一个抽象类 Shape，其中包含两个纯虚函数 getArea() 和 getPerim()，分别用于计算面积和周长，因此 Shape 不能被实例化。

然后，我又定义了两个派生类 Rectangle 和 Circle，它们都继承自 Shape，分别实现了 getArea() 和 getPerim() 函数，以计算矩形和圆形的面积和周长。

最后，在 main() 函数中，我创建了 Rectangle 和 Circle 对象，并分别调用它们的 getArea() 和 getPerim() 函数计算面积和周长，并将结果输出到屏幕上。

希望这个代码对您有所帮助。