Styjun

I am reading Starting out with Java and a challenge presented in the book is to: "Write a class that has three overloaded static methods for calculating the areas of the following geometric shapes: circles, rectangles and cylinders." The area of a circle only requires only one parameter and there was no issue here so I left that method out. But the area of a rectangle and the area of a cylinder both require two parameters:

public class Area
 public static double area(double w, double l)
 
 //Area of rectangle
 return l*w;
 
 public static double area(double r, double h)
 
 //Area of a cylinder
 return Math.PI * (r*r) *h;
 

With the above code I get the warning "duplicate method area(double, double) in type Area." I know that if I simply change the type of one of the parameters I won't have this issue, but is this the only way it can be done? I can't have two overloaded static methods with the same parameter list?

Both of those methods:

• are called 'area'


• take two arguments of type 'double'

so they are indistinguishable. The names you choose for the formal arguments do not factor into the decision, because (aprt from the trivial "because that's how the language works") those names are not written in the source code at the point where a call to area() is made.

Given the problem statement, you've got little choice but to change the type of at least one of the arguments to one of the two overloads. Are integer sizes allowed? Float/double makes me a little nervous: it's too easy to make a mistake.

I understand that this is an exercise in overloading methods in Java, so you've got to follow the problem statement.

However, as a general issue: given a class named Area with a bunch of static area-calculators, IMO it really would be more understandable to name each such area-calculating method to say what it really does. So for example areaOfCircle and areaOfRectangle. Doing different calculations depending on the types of the arguments does not seem to be understandable at a glance the way good names will be.

The area of the circle could be changed to radius as a double, and pi as a float. That way the compiler will recognize a difference in the circle's method. The idea of the lesson is that , as long as you change the parameters in your methods, you can have multiple methods of the same name which is the point of overloading a method.

You can make something like this:

public class Area 

 // Rectangle
 public static double calculateArea(int width, int length) 
 return width * length;
 

 // Cylinder
 public static double calculateArea(double radius, int height) 
 return Math.PI * Math.pow(radius, 2) * height;
 

 // Circle
 public static double calculateArea(double radius) 
 return Math.PI * Math.pow(radius, 2);
 

And then call it using:

Area.calculateArea(2.0); // Call 'Circle' method
Area.calculateArea(2.0, 3); // Call 'Cylinder' method
Area.calculateArea(3, 5); // Call 'Rectangle' method

Here's a contrived answer that satisfies the requirements for 3 overloaded 'area' methods without having to use float or int where we might prefer double.

First the Area class. For each shape, we need 3 things: a (inner) class that holds the values that define the shape; a function that delivers an object of that class; and (crucially) an area() method that accepts a single argument, an object of the inner class. It is this last item that satisfies the "overloaded method" requirement.

class Area {

 static class Circle 
 double radius;
 Circle(double r) radius = r; 
 

 static Circle circle(double r) 
 return new Circle(r);
 

 static double area(Circle c) 
 return PI * c.radius * c.radius;
 

 static class Rectangle 
 double length, width;
 Rectangle(double l, double w) length = l; width = w; 
 

 static Rectangle rectangle(double l, double w) 
 return new Rectangle(l, w);
 

 static double area(Rectangle r) 
 return r.length * r.width;
 

 static class Cylinder 
 double radius, height;
 Cylinder(double r, double h) radius = r; height = h 
 

 static Cylinder cylinder(douvle r, double h) 
 return new Cylinder(r, h);
 

 static double area(Cylinder c) 
 return 2 * PI * c.radius * c.height + // side
 PI * c.radius * c.radius * 2; // ends
 // see note!
 
]

Now, how to use them? These examples show how:

a1 = Area.area(Area.circle(1));
a2 = Area.area(Area.rectangle(2,3));
a3 = Area.area(Area.cylinder(4,5));

The functions like "Circle circle(...) ... " exist so I don't have to write "new" to create a Circle, etc.

Pretty ugly, huh?

Note: your formula for the "area" of a cylinder is actually computing the volume. What exactly do you mean by area of a 3-D solid? If you mean the surface area, then it's the two end circles plus the wrapped-around rectangle that makes the 'side'. Each of the former has area 'pi r^2'; the rectangle has sides '2 pi r' and 'h', thus area '2 pi r h'.