在Main类Java中使用具有继承的类

Question

My super class called Polygon:

public class Polygon
{
private double area;

/**
 * Constructor for objects of class Rectangle
 */
public Polygon(double area)
{
    this.area = area;
}

/**
 * Mutator method that sets the area
 */
public void setArea(double area)
{
    this.area = area;
}

/**
 * Accessor method that returns the area
 */
public double getArea()
{
    return area;
}
}

My Square class that extends Polgyon:

public class Square extends Polygon
{
private double perimeter;

/**
 * Constructor for objects of class Square
 */
public Square(double area)
{
    super(area);
}

/**
 * calculates the perimeter of the square using area inherited from Polygon
 */
public void calcPerimeter()
{
    perimeter = Math.sqrt(getArea()) * 4; //in a square, area is the square root
}

/**
 * Accessor method that returns the perimeter
 */
public double getPerimeter()
{
    calcPerimeter();
    return perimeter;
}
}

I have a circle and rectangle class pretty much the same thing except with length and width, and circumference.

In the main class, I want to allow the user to put in an area and then receive the perimeter of a square with that area, circumference of a circle with that area, etc. I don't know if I did it correctly though...I created each object and put in the same input. Here is my main class:

public class PolygonMain
{
public static void main(String[] args)
{
    double input = Double.parseDouble(args[0]);
    Polygon polygon = new Polygon(input);
    Square square = new Square(input);
    Circle circle = new Circle(input);
    Rectangle rectangle = new Rectangle(input);
    System.out.println("Area:" + " " + polygon.getArea() + ".");
    System.out.println("Perimeter:" + " " + square.getPerimeter() + ".");
    System.out.println("Circumference:" + " " + circle.getCircumference() + ".");
    System.out.println("Length:" + " " + rectangle.getLength() + ".");
    System.out.println("Width:" + " " + rectangle.getWidth() + ".");
}
}

As you can see in my main class, I put in the user input (args[0]) into each constructor's parameter.....which kind of makes the inheritance part of constructors ie super(area)....useless. Is it necessary to have to create every new shape? Also, what if I was to implement the Scanner class into the main class? Let's say, the user can type in area values and command back information on subclass shapes and then do this with multiple values of area? How would I go about doing that, as I have no idea how with having to create objects in the main class. We just started using the Main method; our IDE for the class is BlueJ, which doesn't require it. I hope my question isn't too confusing with it's wording and I apologize if I formatted this post wrong, as this is my first post. Thank you.

PS: I forgot to mention to ignore that square is a rectangle. My professor made a mistake and by accidentally instructed us to extend rectangle from square.

PS: besides in the main class, where you guys suggested adding each different shape to a collection and then iterating over each and printing out attributes, do you guys have any other alternatives? How would I do it with the Scanner class? Because in the above situation, I have tl create all the objects. I'm trying to get as much practice as possible with main class because I'm severely lacking in it due to BlueJ.

Answer 1

As far as I can see, it would be best to make Polygon abstract, and have it define an abstract method getPerimiter() :

public abstract double getPerimiter();

That way, all your subclasses would need their own implementation of that method. That's reasonable because they all use different calculations.

So you class Polygon would look like this:

public abstract class Polygon {

  protected double area; //not private, we want sub-classes to see this field

  public Polygon(double area) {
    this.area = area;
  }

  public abstract double getPerimiter();
}

And your square, for example, would look like this:

public class Square extends Polygon {

  public Square(double area) {
    super(area);
  }

  public double getPerimiter() {
    return Math.sqrt(area) * 4;
  }

}

All your subclasses must call the constructor defined in Polygon because there's no default constructor, hence the super(area) call in Square. Alternatively, you could do away with all the constructors and instead have a setArea(double area) method in Polygon.

Answer 2

Calling super(area) in the constructor is necessary because Polygon doesn't have a constructor with no-args. Yes it is necessary to create every new shape because you work with objects and you need to create them before you can use them. If you want to practice inheritance with this example you probably want to do something like this in your main:

 Polygon[] shapes=new Polygon[4];
 shapes[0]=new Polygon(input);
 shapes[1] = new Square(input);
 shapes[2] = new Circle(input);
 shapes[3] = new Rectangle(input);

 for(Polygon p:shapes){
     System.out.println(p.getArea());
 }

And see that all the different objects in the array inherit the getArea() method from Polygon. On the other hand if you want to call a specific method that's been provided in the subclass - say getPerimeter() - you have to cast the reference to subclass or you will not be able to use it:

Polygon mySquare=new Square(100);
System.out.println(((Square)mySquare).getPerimeter());

Answer 3

what you might want, is using a method shared by all your inheritance classes.

Polygon could have a method, which gives you the area - public double calculateArea() but, you don't know, how the classes will calculate their area, so make it abstract

public abstract double calculateArea()

in Square:

public class Square extends Polygon
    {
    private double side;

    public Square(double side)
    {
        this.side= side;
    }

    @Override
    public double calcArea()
    {
        return side * side;
    }


    public double getSide()
    {
        return side;
    }
}

you can now do the same with circle:

public class Circle extends Polygon
    {
    private double radius;

    public Square(double radius)
    {
        this.radius= radius;
    }

    @Override
    public double calcArea()
    {
        return radius * radius * Math.PI;
    }


    public double getRadius()
    {
        return radius;
    }
}

in your Main Method, you set the Radius and the side length of circle and square:

Circle c = new Circle(5);
Square s = new Square(5);

and then you can make a List of Polygons, iterate over it, and get the area:

ArrayList<Polygon> list = new ArrayList<>();
list.add(c);
list.add(s);

for (Polygon element: list){
   System.out.println(list.calcArea());
}