java - 需要一些帮助来创建 Java 的 Triangle 类

Question

我应该为我在学校的项目制作自己的 Java Triangle 类。新三角形按从左到右的顺序获取 3 个点的 (x,y) 坐标。我主要关心的是我制作 sideAB、sideBC 和 sideAC 实例变量以及它们在构造函数中初始化它们的方式。另外， maxAngle 和 minAngle 看起来一团糟，我希望它有 angleA、angleB 和 angleC 变量，类似于我拥有侧面的方式。另外，我不确定我的变量是否应该是静态的。如果我的代码真的很菜鸟，我很抱歉，但这是我为我的类(class)编写的第一个 Java 项目。

这就是我所拥有的。它有效，但我认为我没有以正确的方式做所有事情:

public class Triangle {
    private double ax;
    private double ay;
    private double bx;
    private double by;
    private double cx;
    private double cy;
    //added these variables because I use them so frequently when calculating angles, area, perimeter, etc.
    private double sideAB;
    private double sideBC;
    private double sideAC;

    public Triangle(double x1, double y1, double x2, double y2, double x3, double y3)
    {
        ax = x1;
        ay = y1;
        bx = x2;
        by = y2;
        cx = x3;
        cy = y3;
        sideAB= Math.abs(Math.sqrt(Math.pow(bx-ax,  2)+Math.pow(by-ay, 2)));
        sideBC= Math.abs(Math.sqrt(Math.pow(cx-bx,  2)+Math.pow(cy-by, 2)));
        sideAC= Math.abs(Math.sqrt(Math.pow(cx-ax,  2)+Math.pow(cy-ay, 2)));
    }
    public double getPerimeter()
    {
        //add the 3 sides together for the perimeter
        double perimeter = sideAB + sideBC + sideAC;
        return perimeter;
    }
    public double getArea()
    {
        //used Heron's formula to find the area of the triangle
        double s = (sideAB + sideBC + sideAC)/2;
        double area = Math.sqrt(s*(s - sideAB)*(s - sideBC)*(s - sideAC));
        return area;
    }
    public double getSideAB()
    {
        return sideAB;
    }
    public double getSideBC()
    {
        return sideBC;
    }
    public double getSideAC()
    {
        return sideAC;
    }
    public double getAngleC()
    {
        //Law of cosines to find the angle
        double a2 = Math.pow(sideAB, 2);
        double b2 = Math.pow(sideBC, 2);
        double c2 = Math.pow(sideAC, 2);
        double cosC = ((b2 + c2)-a2)/((2*sideBC)*sideAC);
        double angleC = Math.acos(cosC);
        angleC = Math.toDegrees(angleC);
        return angleC;
    }
    public double getAngleB()
    {
        double a2 = Math.pow(sideAB, 2);
        double b2 = Math.pow(sideBC, 2);
        double c2 = Math.pow(sideAC, 2);
        double cosB = ((a2+b2-c2)/(2*sideAB*sideBC));
        double angleB = Math.acos(cosB);
        angleB = Math.toDegrees(angleB);
        return angleB;
    }
    public double getAngleA()
    {
        double a2 = Math.pow(sideAB, 2);
        double b2 = Math.pow(sideBC, 2);
        double c2 = Math.pow(sideAC, 2);
        double cosA = ((a2+c2-b2)/(2*sideAB*sideAC));
        double angleA = Math.acos(cosA);
        angleA = Math.toDegrees(angleA);
        return angleA;
    }
    public double maxSide()
    {
        //if-else if-else statements for max and min sides functions
        if (sideAB >= sideBC && sideAB >= sideAC)
        {
            return sideAB;
        }
        else if(sideBC >= sideAB && sideBC >= sideAC)
        {
            return sideBC;
        }
        else
        {
            return sideAC;
        }
    }
    public double minSide()
    {
        if (sideAB <= sideBC && sideAB <= sideAC)
        {
            return sideAB;
        }
        else if(sideBC <= sideAB && sideBC <= sideAC)
        {
            return sideBC;
        }
        else
        {
            return sideAC;
        }
    }
    public double maxAngle()
    {
        double a2 = Math.pow(sideAB, 2);
        double b2 = Math.pow(sideBC, 2);
        double c2 = Math.pow(sideAC, 2);
        double cosC = ((b2 + c2)-a2)/((2*sideBC)*sideAC);
        double angleC = Math.acos(cosC);
        angleC = Math.toDegrees(angleC);
        double cosB = ((a2+b2-c2)/(2*sideAB*sideBC));
        double angleB = Math.acos(cosB);
        angleB = Math.toDegrees(angleB);
        double cosA = ((a2+c2-b2)/(2*sideAB*sideAC));
        double angleA = Math.acos(cosA);
        angleA = Math.toDegrees(angleA);
        if (angleA >= angleB && angleA >= angleC)
        {
            return angleA;
        }
        else if(angleB >= angleA && angleB >= angleC)
        {
            return angleB;
        }
        else
        {
            return angleC;
        }       
    }
    public double minAngle()
    {
        double a2 = Math.pow(sideAB, 2);
        double b2 = Math.pow(sideBC, 2);
        double c2 = Math.pow(sideAC, 2);
        double cosC = ((b2 + c2)-a2)/((2*sideBC)*sideAC);
        double angleC = Math.acos(cosC);
        angleC = Math.toDegrees(angleC);
        double cosB = ((a2+b2-c2)/(2*sideAB*sideBC));
        double angleB = Math.acos(cosB);
        angleB = Math.toDegrees(angleB);
        double cosA = ((a2+c2-b2)/(2*sideAB*sideAC));
        double angleA = Math.acos(cosA);
        angleA = Math.toDegrees(angleA);
        if (angleA <= angleB && angleA <= angleC)
        {
            return angleA;
        }
        else if(angleB <= angleA && angleB <= angleC)
        {
            return angleB;
        }
        else
        {
            return angleC;
        }       
    }
}

Answer 1

三角形(至少在二维欧几里得空间中)的显着属性是它的三个点。

就是这样，这就是您需要存储的全部。其他一切都可以据此计算。您不需要边长或顶点角度，它们都可以从这三个点导出。

我的建议是简单地创建一个 Point 类型，然后从其中的三个构建您的 Triangle 类型。

如果您确定这些派生值的计算成本太高，并且只有到那时，您才应该考虑缓存该信息。但我怀疑情况会是这样。如果事实确实如此，那么(至少)有两种方法。

首先是每当非派生值发生变化时计算派生值。这样做的优点是可以确保每当您更改某些内容时所有值都是最新的，并且简化了代码(每个 setSomething() 方法和构造函数只需调用 calcAllDerivedValues( )方法)。

其次，每当您更改非派生值时，您都可以将派生值标记为脏值。然后，每当您需要派生数据时，计算它的方法就可以检查它们是否脏，然后计算(并缓存)它们(如果脏)。

如果它们不脏，它们只会返回缓存的值。这有点复杂，但可以删除不必要的计算，特别是如果每​​个派生值都有一个脏标志 - 您只在需要时计算您需要的内容。

而且，对于您关于static的具体问题，您仅使用静态类级变量(如果它们在所有实例之间共享)。由于角度或边长特定于一个实例，因此它们不应该是静态的。

<小时/>

这就是我的开始方式。首先，一个 Point 类，它具有 x 和 y 成员(以及它们的 getter 和 setter)，并且能够计算距离和与另一点的角度(相对于“直线向上”等固定角度)，例如:

private double x, y;

public double getX();
public double getY();
public void setX(double newX);
public void setY(double newY);
public void setXY(double newX, double newY);
public double getDistance (Point other);
public double getAngle (Point other);

然后，您的 Triangle 类需要其中三个点:

private Point a, b, c;

以及适当的 setter 和 getter，以及计算所需的派生属性所需的任何函数。

那就是这样的:

• 通过计算 a->b、b->c 和 a->c 之间的距离来获取周长(通过Point 类 getDistance() 方法)，然后添加它们。
• 使用相同的信息(三个线长)来获取面积。
• 根据 Point 类 getAngle() 结果之间的差异获取角度(作为示例)a->b 和a->c(对于角度 A)。如果这个角度大于 180 度，显然这是三角形的外角，您应该用 360 度减去它来得到内角。

而且您不需要为每种情况复制所有代码。例如，您希望能够计算出三个顶点中任意一个的角度。您不需要为每一个复制所有智能代码。

而是编写复杂的代码一次并以三种不同的方式调用它。

我的意思是:

// Can just call Point stuff directly for distances (simple code).
double getDistAB() { return a.getDistance (b); }
double getDistAC() { return a.getDistance (c); }
double getDistBC() { return b.getDistance (c); }

double getPerimeter() { return getDistAB() + getDistAC() + getDistBC(); }

// Returns the angle inside triangle at the first vertex (complex code).
double getAngleAtPointX (Point x, Point y, Point z) {
    double angle = x.getAngle (y) - x.getAngle (z);
    if (angle < 0)
        angle = -angle;
    if (angle > 180)
        angle = 360 - angle;
    return angle;
}

// Then just call that with different arguments.
double getAngleA() { return getAngleAtPoint (a, b, c); }
double getAngleB() { return getAngleAtPoint (b, a, c); }
double getAngleC() { return getAngleAtPoint (c, a, b); }