0

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

4 回答 4

2

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

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

我的建议是简单地创建一个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->ca->cPointgetDistance()
  • 使用相同的信息（三行长度）来获取该区域。
  • 根据（例如）和（对于角度 A）的Point类结果之间的差异来获取角度。如果这个角度大于 180 度，显然那是三角形的外角，你应该从 360 度中减去它以获得内角。getAngle()a->ba->c

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

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

我的意思是：

// 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); }
于 2012-10-01T06:18:28.953 回答
1

在大多数情况下，代码是正确的。

但是，最大的问题是您编写的代码多次执行相同的操作。例如这个方法：

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;
    }       
}

计算最大角度，但您可以使用已经实现的方法getAngleA() ，getAngleB()并getAngleC()像这样编写这个：

public double maxAngle() {
  if(getAngleA() => getAngleB() && getAngleA() => getAngleC())
    return getAngleA();
  if(getAngleB() => getAngleA() && getAngleB() => getAngleC())
    return getAngleB();
  return getAngleC();
}
于 2012-10-01T06:21:53.053 回答
0

如果性能很重要，您应该预先计算所有值（假设不能更改三角形的任何点），尤其是角度，如果它们被多次访问。

不，您绝对不应该使用任何静态变量，因为这些变量将由您的 Triangle 类的每个实例共享。

于 2012-10-01T06:23:10.550 回答
0

可以在您的代码中进行的一些修改是：-

  • 创建一个Coordinate类来存储三角形的三个坐标的 x 和 y 坐标。
  • 创建一个Side类来存储所有三个面。

  • 创建一个角度类来查找和存储所有角度..

  • 现在，不必在一个类中创建所有内容，您可以在各自的类中计算它们..然后从那里获取..

  • EG： -让一个特定的Angle实例找出它自己的角度，你可以从那里得到角度。所以，你不必编写逻辑来创建三次角度。

  • 您可以将您的findMaxSide(), 和findMinSide()代码移动到您的Side类中。因为理想情况下，您的方法应该在class containing the information您的方法正在使用的那个中。

  • 同样移动findMaxAngle()到findMinAngle()你的角度类。

所以，我在这里为您提供Angle可以使用的课程..您可以自己创建您的Coordinate课程Side：-

public class Angle {

    private double angle;

    public Angle() {

    }

    public double getAngle() {
        return this.angle;
    }

    public void setAngle(Side side1, Side side2, Side side3) {

        double a2 = Math.pow(side1.getLength(), 2);
        double b2 = Math.pow(side2.getLength(), 2);
        double c2 = Math.pow(side3.getLength(), 2);
        double cosB = ((a2+b2-c2)/(2*side1.getLength()*side2.getLength()));

        double tempAngle = Math.acos(cosB);

        this.angle = Math.toDegrees(tempAngle);
    }

    public Angle maxAngle(Angle angle1, Angle angle2) {

        Angle temp = angle1.getAngle() > angle2.getAngle() ? angle1 : angle2;
        return temp.getAngle() > this.getAngle() ? temp : this;
    }

    public Angle minAngle(Angle angle1, Angle angle2) {

        Angle temp = angle1.getAngle() < angle2.getAngle() ? angle1 : angle2;
        return temp.getAngle() < this.getAngle() ? temp : this;
    }
}

side1并且side2是您要在其之间找到角度的边..

你可以从你的Triangle班级中使用这个班级，如下所示： -

public class Triangle {

    private Coordinate a;
    private Coordinate b;
    private Coordinate c;
    //added these variables because I use them so frequently when calculating angles, area, perimeter, etc.

    private Side sideAB;
    private Side sideBC;
    private Side sideAC;

    private Angle angleA = new Angle();
    private Angle angleB = new Angle();
    private Angle angleC = new Angle();

    public Triangle(double x1, double y1, double x2, double y2, double x3, double y3)
    {

        a = new Coordinate(x1, y1);
        b = new Coordinate(x2, y2);
        c = new Coordinate(x3, y3);

        sideAB= new Side(a, b);
        sideBC= new Side(b, c);
        sideAC= new Side(a, c);

        angleA.setAngle(sideAB, sideAC, sideBC);
        angleB.setAngle(sideAB, sideBC, sideAC);
        angleC.setAngle(sideAC, sideBC, sideAB);
    }

    /** Your other methods to calculate Perimeter and Area **/
}

我刚刚展示了构造函数，展示了如何设置三角形类的所有三个属性。

我认为这么多信息将帮助您继续创建一个好的设计。

于 2012-10-01T06:44:37.100 回答