writing a triangle equals method

Question

im having to write a code that creates a triangle through a class that extends Geometric object. then we have to write an equals method to compare to triangles. im not sure exactly how to call the other triangle to compare it.

    public class Triangle extends GeometricObject {
private double side1 ;
private double side2 ;
private double side3 ;
public final double DEFAULT = 1.0;

public Triangle(){
    super();
    side1= DEFAULT;
    side2= DEFAULT;
    side3= DEFAULT;
}
public Triangle(String color, boolean filled, double side1, double side2, double side3)throws IllegalTriangleException{
    super(color,filled);
    this.side1=side1;
    this.side2=side2;
    this.side3=side3;
    if (side1>=side2+side3||side2>=side1+side3|| side3>=side1+side2){
        throw new IllegalTriangleException(side1,side2,side3);
    }
}
public double getSide1() {
    return side1;
}
public void setSide1(double side1) {
    this.side1 = side1;
}
public double getSide2() {
    return side2;
}
public void setSide2(double side2) {
    this.side2 = side2;
}
public double getSide3() {
    return side3;
}
public void setSide3(double side3) {
    this.side3 = side3;
}
public double getArea(double s1, double s2, double s3){
    side1= s1;
    side2= s2;
    side3= s3;
    double area = .5*(s1*s2*s3);
    return area;
}
public double getPerimeter(double s1, double s2, double s3){
    side1=s1;
    side2=s2;
    side3=s3;
    double perim = s1+s2+s3;
    return perim;
}
public String toString(){

    return super.toString()+ "triangle side 1 +"+ side1+ " side 2= "+side2+" side 3= "+side3;
}
public boolean equals(Object o){

}
  }


public class TestTriangle {
public void main (String[]args){
    try {
        GeometricObject tri1 = new Triangle ("yellow",true,1.0,1.5,1.0);
        GeometricObject tri2 = new Triangle ("red ", true, 2.0,3.7,5.0);
    } catch (IllegalTriangleException e) {
        System.out.print("invalid Side Lengths");
    }


}
}   

Answer 1

The OP's question appears to be: "im not sure exactly how to call the other triangle to compare it."

This is how you would call the .equals() method in order to compare the 2 triangles for equality:

tri1.equals(tri2);

Apache Common's EqualsBuilder class is useful in its own right. But it is also useful for learning how to write your own equals method.

In general, in your equals method, you want to:

Check if the input is null, and if so, return false.

o == null

Check if the input parameter is of the same class as "this", return false if it isn't.

this.getClass() == o.getClass()

Lastly, compare each instance member variable for equality.

this.side1 == o.side1 && this.side2 == o.side2 && this.side3 == o.side3

A complete and more robust implementation might look like this (that does not consider the order of the sides):

    @Override
    public boolean equals(Object o) {
        if (null == o) return false;
        if (this.getClass() != o.getClass()) return false;

        Triangle t = (Triangle)o;
        List<Double> oSides = new ArrayList<Double>();
        oSides.add(t.side1);
        oSides.add(t.side2);
        oSides.add(t.side3);
        for (Double d : oSides) {
            if (d.equals(this.side1)) {
                oSides.remove(d);
                break;
            }
        }
        for (Double d : oSides) {
            if (d.equals(this.side2)) {
                oSides.remove(d);
                break;
            }
        }
        for (Double d : oSides) {
            if (d.equals(this.side3)) {
                oSides.remove(d);
                break;
            }
        }
        return oSides.isEmpty();
    }

Answer 2

What does it mean for two triangles to be equal? Does it mean the areas are the same? That seems too loose. Does it mean the sides are the same in the same order? That seems too strict? If you don't have a better definition, I'd compare each of the sides regardless of order.

And what does it mean for two doubles to be equal? They just need to be within a small delta.

public class Triangle {
    // a small delta for comparing doubles
    private static final double DELTA = 0.00000001;

    // the sides
    private double side1;
    private double side2;
    private double side3;

    /**
     * Constructs a triangle with these sides.
     * @param side1 the first side
     * @param side2 the second side
     * @param side3 the third side
     */
    public Triangle(double side1, double side2, double side3) {
        if (side1 <= 0 || side2 <= 0 || side3 <= 0)
            throw new IllegalArgumentException("Sides must be positive.");

        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    /**
     * Check if each of the 3 sides are equal - regardless of order.
     */
    @Override
    public boolean equals(Object obj) {
        boolean result = false;
        if (obj instanceof Triangle) {
            Triangle that = (Triangle)obj;

            double[] sides1 = { this.side1, this.side2, this.side3 };
            Arrays.sort(sides1);

            double[] sides2 = { that.side1, that.side2, that.side3 };
            Arrays.sort(sides2);

            result = equalsDelta(sides1[0], sides2[0])
                    && equalsDelta(sides1[1], sides2[1])
                    && equalsDelta(sides1[2], sides2[2]);
        }
        return result;
    }

    /**
     * Check if these numbers are equal within a small delta.  Assumes the
     * numbers are positive - because they represent sides of a triangle.
     *
     * @param d1 the first number
     * @param d2 the second number
     * @return true if within a delta
     */
    private static boolean equalsDelta(double d1, double d2) {
        double diff = (d1 < d2) ? d2 - d1 : d1 - d2;
        return diff < DELTA;
    }

    // hashCode(), toString(), and so on...
}