Comparable interface

[diamonddragon]

Say there are GeometricObject, Circle, Rectangle class as follows:

public abstract class GeometricObject extends Object implements Comparable<Object> {
    public int prc;
    public String color;
    
    public void setColor(String color) {
        this.color = color;
    }

    public abstract double getArea();    
    
    public static Comparable max(Comparable c1, Comparable c2) {
        if (c1.compareTo(c2) > 1)
            return c1;
        else
            return c2;        
    }
    
}

public class Circle  extends GeometricObject {
    private double radius;
    public int prc;

    public Circle() {                
        super.prc = 1;        
    }

    Circle(double radius) {
        this.radius = radius;    
    }          
    
    @Override
    public double getArea() {
        return radius * radius * Math.PI;
    }                

    @Override
    public int compareTo(Object o) {
        if (getArea() > ((Circle) o).getArea()) {
            return 1;
        } else if (getArea() < ((Circle) o).getArea()) {
            return -1;
        } else {
            return 0;
        }      
    }
}

public class Rectangle extends GeometricObject {
    private double width;
    private double height;

    public Rectangle() {
    }

    public Rectangle(double width, double height, String color) {
        this.width = width;
        this.height = height;
        setColor(color);
    }        

    /** Return area */
    @Override
    public double getArea() {
      return width * height;
    }

    @Override
    public int compareTo(Object o) {
        if (getArea() > ((Rectangle) o).getArea()) {
            return 1;
        } else if (getArea() < ((Rectangle) o).getArea()) {
            return -1;
        } else {
            return 0;
        }
    }
    
}

And a tester:

public class TestCircleRectangle {

    public static void main(String[] args) {
        Circle c1 = new Circle(5);
        Circle c2 = new Circle(7);      
        Rectangle r1 = new Rectangle(5, 5, "red");
        Rectangle r2 = new Rectangle(7, 7, "red");
        
        Comparable com1 = GeometricObject.max(r1, r2);//ok
        Comparable com2 = GeometricObject.max(r1, c2);//error                                       
    }
}

As I'm doing this exercize and do not have answer but I have You, I will appreciate if You could give me some answers on this matter.

Am I using Comparable interface right?
How I'm suppose to handle error comparing objects of type Circle and Rectangle?

[kjkrum]

You're using it wrong. A class that implements Comparable should implement it with itself as the type parameter:

public class Circle implements Comparable<Circle> {
    @Override
    int compareTo(Circle other) {
        // ...
    }
}

[Tolls]

Well, Comparable<GeometricObject>.
Then GeometricObject should do the comparison.
If GeometricObjects are not Comparable with each other (a Circle cannot be compared with a Rectangle) then the subclasses should implement Comparable.

Now, from the code you are using, you are comparing based on the result of the getArea() method, so I'd say GeometricObject should implement the compareTo method, and not the subclasses.

[diamonddragon]

You're using it wrong. A class that implements Comparable should implement it with itself as the type parameter:

public class Circle implements Comparable<Circle> {
    @Override
    int compareTo(Circle other) {
        // ...
    }
}

If Circle and Rectangle extends GeometricObject and GeometricObject implements Comparable, does Circle and Rectangle implement Comparable?

[Tolls]

Yes, they are Comparable objects.
But it makes no sense for them to implement the compareTo method.

[kjkrum]

If Circle and Rectangle extends GeometricObject and GeometricObject implements Comparable, does Circle and Rectangle implement Comparable?

Yes, but I don't think that's what you want. You probably want Circle to implement Comparable<Circle>, not Comparable. Then you will get a compile-time error if you try to compare a Circle to a Rectangle.

But, as Tolls noted, if you do want to be able to compare Circles and Rectangles based on a property (such as area) that is common to both of them, then you would want them both to implement Comparable<GeometricObject>. And you would not explicitly implement Comparable in Circle or Rectangle; they would inherit it from GeometricObject. It might look like this:

public class GeometricObject implements Comparable<GeometricObject> {
    // ...
    @Override
    public int compareTo(GeometricObject other) {
        return this.getArea() - other.getArea();
    }
}

[diamonddragon]

Thank You for answers, very much.
Now it looks like this.
Do I need abstract method at line 6 in GeometricObject class?
Or I'm using that method signature from Comparable interface?

public abstract class GeometricObject implements Comparable<GeometricObject> {        
    
    public abstract double getArea();    
    
    @Override
    public abstract int compareTo(GeometricObject c); //do I need this abstract method?
    
    public static Comparable max(GeometricObject o1, GeometricObject o2) {
        if (o1.compareTo(o2) > 1)
            return o1;
        else
            return o2;        
    }                   
}

public class Circle  extends GeometricObject {
    private double radius;        
    
    @Override
    public double getArea() {
        return radius * radius * Math.PI;
    }            

    @Override
    public int compareTo(GeometricObject o) {
        if (getArea() >  o.getArea()) {
            return 1;
        } else if (getArea() < o.getArea()) {
            return -1;
        } else {
            return 0;
        }   
    }
}

public class Rectangle extends GeometricObject {
    private double width;
    private double height;   

    /** Return area */
    @Override
    public double getArea() {
      return width * height;
    }

    @Override
    public int compareTo(GeometricObject o) {
        if (getArea() > o.getArea()) {
            return 1;
        } else if (getArea() < (o).getArea()) {
            return -1;
        } else {
            return 0;
        }
    }    
}

[Tolls]

No...move your compareTo code into GeometricObject.
Both those methods are identical, so you may as well have a single one in GeometricObject.

[kjkrum]

The compareTo(...) method in GeometricObject does not need to be abstract. And you do not need to override it in Circle or Rectangle, since they both make the comparison in exactly the same way. I would just move your implementation of the method from Circle into GeometricObject and have Circle and Rectangle inherit it.

[diamonddragon]

Finally, compareTo in GeometricObject Override compareTo in Comparable interface, and sice Circle and Rectangle extends GeometricObject, they inherit compareTo method from instance of GeometricObject:

public abstract class GeometricObject  implements Comparable<GeometricObject>{     
    
    public abstract double getArea();    
    
    @Override
    public int compareTo(GeometricObject o) {
        if (getArea() > o.getArea()) {
            return 1;
        } else if (getArea() < o.getArea()) {
            return -1;
        } else {
            return 0;
        }
    }
    
    public static Comparable max(GeometricObject o1, GeometricObject o2) {
        if (o1.compareTo(o2) > 1)
            return o1;
        else
            return o2;        
    }                 
}

public class Circle  extends GeometricObject {
    private double radius;
    
    @Override
    public double getArea() {
        return radius * radius * Math.PI;
    }    
}

[kjkrum]

Looks good to me!

[diamonddragon]

Just that I don't see much use of Comparable interface in this case.

[kjkrum]

The only reason I've ever made my classes Comparable is so I could use the list sorting methods in the Collections class.

[diamonddragon]

So, using interface is to use patern for some methods headers that has to be implemented in class that implements specific interface?

[kjkrum]

Correct.

[diamonddragon]

Is it ok if say ClassX extends ClassY and ClassX implements InterfaceY are much similar except interface is not allowed to have method implementation and all inteface fields are final and static?

[kjkrum]

The most important way in which "X extends Y" and "X implements Y" are similar is that in either case, you can treat the X as a Y. You can declare variables of type Y and use them to store objects of any class that extends Y (if Y is a class) or implements Y (if Y is an interface).

[kjkrum]

Couldn't tell you. That question is unrelated to the subject, so I'd start another thread.