Question

所以，经过多年的OOP，我从一个大学课程中完成了一个非常简单的家庭作业，以实现一个简单的面向对象的结构。

要求的设计：

实施面向对象的解决方案，以创建以下形状：
椭圆，圆形，方形，矩形，三角形，平行四边形。
创建的每个形状必须具有以下参数：唯一ID，颜色。

关注功能：颜色变化，移动，区域，周长，在里面，复制。

不需要进行有效性测试（不在课程中，也不在用户输入中）。

我的设计：

总的来说，一个非常简单的方法，shape_class / non-circular是抽象的，而矩形/方形被组合成一个类，因为它们包含完全相同的参数，并且不需要有效性测试（没有理由将它们分成两个）。 / p>

Shape class - 实现静态id（唯一id）和处理颜色名称的init函数。

public abstract class shape_class {

    static int STATIC_ID;
    int id;
    String color_name;

    public shape_class(String color_name_input) {
        this.id = STATIC_ID;
        shape_class.STATIC_ID+=1;
        if (Arrays.asList(toycad_globals.ALLOWED_COLORS).contains(color_name_input))
        {
            this.color_name = color_name_input;
        }
    }

    public void change_color(String color_name_input) {
        if (Arrays.asList(toycad_globals.ALLOWED_COLORS).contains(color_name_input)) {
            this.color_name = color_name_input;
        }
    }

    public abstract shape_class return_copy();
    public abstract void move(double x, double y);
    public abstract double area();
    public abstract double circumference();
    public abstract boolean is_inside(double x, double y);
}

**非圆形** - 接收一系列点（定义对象）并实现几乎所有必需的功能。

public abstract class non_circullar extends shape_class {
    List<line> line_list = new ArrayList<line>();
    List<point> point_list = new ArrayList<point>();

    non_circullar(String color_name, point...input_point_list) {
        super(color_name);
        this.point_list = Arrays.asList(input_point_list);
        for (int current_index =0; current_index< (input_point_list.length); current_index++) {
            point current_first_point = input_point_list[current_index];
            point current_second_point = input_point_list[(current_index+1)%input_point_list.length];
            this.line_list.add(new line(current_first_point, current_second_point));
        }
    }

    public point[] get_point_list_copy() {
        int index = 0;
        point [] new_array = new point[this.point_list.size()];
        for (point current_point:this.point_list) {
            new_array[index] = current_point.return_copy();
            index+=1;
        }
        return new_array;
    }

    public double circumference() {
        double sum = 0;
        for (line current_line :this.line_list) {
            sum += current_line.get_length();
        }
        return sum;
    }

    public void move(double x, double y) {
        for (point current_point :this.point_list) {
            current_point.move(x, y);
        }
    }

    public boolean is_inside(double x, double y) {
        int i;
        int j;
        boolean result = false;
        for (i = 0, j = this.point_list.size() - 1; i < this.point_list.size(); j = i++) {
            if ((this.point_list.get(i).y > y) != (this.point_list.get(j).y > y) &&
                (x < (this.point_list.get(j).x - this.point_list.get(i).x) * (y - this.point_list.get(i).y) / 
                        (this.point_list.get(j).y-this.point_list.get(i).y) + this.point_list.get(i).x)) 
           {
              result = !result;
           }
        }
        return result;
    }

    int get_top_left_line_index() {
        int top_left_line_index = 0;
        int index = 0;
        point best_point = this.line_list.get(0).get_average_point();
        point current_point;
        for (line current_line :this.line_list) {
            current_point = current_line.get_average_point();

            if (current_point.x < best_point.x) {
                best_point = current_point;
                top_left_line_index = index;
            } else if (current_point.x == best_point.x && current_point.y > best_point.y) {
                best_point = current_point;
                top_left_line_index = index;
            }
            index +=1;
        }
        return top_left_line_index;
    }
}

问题：

对于这项任务，设计问题减少了40分：

1）圆是一个椭圆，因此需要从中继承（即使它们没有参数）。

2）矩形/正方形是两个不同的实体，即使在这个实现中它们完全相同（没有有效性测试）。

我很乐意从社区获得有关此设计的一些意见，设计问题是否合法？是否可以做得更好？

修改1：

椭圆表示为：两点和d（对于椭圆上的点，它与两点之间的距离必须等于d）。

圆圈表示为：中心和半径。

我发现很难理解他们如何分享常见的参数。

Answer 1

我建议你遵循这个方案：

您需要先根据边的数量对形状进行分类，然后再按常用特征进行分类。然后你必须认识到以下事实：

circle只是ellipse
square只是rectangle
rectangle和parallelogram都有4条边
与parallelogram不同，rectangle 所有的角度为90°。

这是一个根据您的需求的简化方案：

椭圆，圆，正方形，矩形，三角形，平行四边形

编辑：请注意，还存在以下层次结构。 rectangle和parallelogram都具有相同长度的相反边。最后，它取决于首选的解释以及更适合您的情况（感谢@Federico klez Culloca）：

Quadrilateral <- Parallelogram <- Rectangle <- Square

使其可扩展：如果包含更复杂的基本几何形状，我可能会将polygon置于shape之下，然后通过凸性区分后代首先是非凸性。

Answer 2

您使用的设计不是主意（恕我直言）。

首先，将non-circular重命名为Polygon（另外，我们将第一个字母大写）。

根据实施情况，Circle是特定的Ellipse，所以我会在这里使用继承

Shape < -- Circular < -- Ellipse < -- Circle
      < -- Polygon < -- Triangle      < -- Equilateral
                                      < -- ... //don't know the english names of those triangles 
                   < -- Quadrilateral < -- Square
                                      < -- Rectangle
                                      < -- ...
                   < -- Hexagon
                   < -- ...

Polygon的每个子类都是抽象的，它们用于验证角点数。

一般情况下，我会根据几何规则（相同的宽度和高度）（Square）链接Rectangle和Square extends Rectangle，但会根据您使用Point的实施情况进行链接和Line，这不是必需的但是使用两个类仍然可以在将来进行一些验证（Square的每个Line需要具有相同的长度，...）。

这表明设计主要取决于要求，而不仅仅取决于主题。

关于Ellipse和Circle。 Ellipse是两点的形式，如果这些点相同，则为Circle，这可以是链接;）

面向对象的设计 - 形状

2 个答案: