抽象类的方法重写和方法重载

Question

I have to make one abstract class called Shape.

This abstract class contains one method that is also abstract GetArea(double height, double width); .

Then i am making inheritance as follow.

Rectangle : Shape

and

Oval : Shape

so in this case i am able to override GetArea() with 2 arguments necessary in method.

Now i have to make Circle : Oval inheritance .

So again to calculate area i have to override GetArea method.

But in this case logically it needs only one perameter for radius.

What can i do in this case?

If i make one more method in shape class for overloading with one argument GetArea(double height) then in that case i have to override it in Rectangle and Oval class which is not necessary?

what is the possible solution?

The methods in the Shape class must be abstract and methods in subclass must be parameterized.

Answer 1

You could make the parameters of the shape part of the constructor, or make properties for them.

public class Rectangle : Shape
{
    public double Width{ get; set;}

    public double Height{ get; set;}   

    public double GetArea() {return Width * Height;}

}

Answer 2

The method parameters are part of the method definition, and as such cannot be altered when you override them.

Personally I would add a parameterless method to calculate the area, and add class-specific properties in the derived classes.

public abstract class Shape {
    public abstract double GetArea();
}

public class Rectangle : Shape {
    public double Height { get; set; }
    public double Width { get; set; }
    public override double GetArea() {
        return Height * Width;
    }
}

public class Oval : Shape {
    public double Radius { get; set; }
    public override double GetArea() {
        return ...;
    }    
}

Answer 3

If the method absolutely has to have parameters (which somewhat defeats the purpose of using OOP here, since the shape's dimensions should be defined in the object and not passed in as parameters), then you've got to go with something, and I guess width and height as good as anything (though this excludes having the design work with a wide variety of shapes).

Here's one approach you could take:

public abstract class Shape
{
    public abstract double GetArea(double width, double height);
}

public class Oval : Shape
{
    public override double GetArea(double width, double height)
    {
        return Math.PI * width * height / 4;
    }
}

public class Circle : Oval
{
    public override double GetArea(double width, double height)
    {
        if (width != height)
        {
            throw new ArgumentException("width and height of a circle must be equal");
        }
        return base.GetArea(width, height);
    }

    // Class-specific convenence method. 
    // Completely separate from two-parameter version of GetArea
    public double GetArea(double diameter)
    {
        return GetArea(diameter, diameter);
    }
}

As noted in the comments, the single-parameter version of GetArea here is completely disconnected from the inherited two-parameter version, but this does demonstrate the use of the inheritance chain and avoiding duplicate code.

Answer 4

In your case you're dealing with class instances, so each GetArea method should not receive parameters. Instead they should be properties of the corresponding classes:

abstract class Shape
{
    abstract int GetArea();
}

class Circle : Shape
{
    public double Radius {get; set;}
    public override int GetArea(){ return Math.PI * Radius * Radius;}
}

class Rectangle : Shape
{
    public double Width{ get; set;}    
    public double Height{ get; set;}   
    public double GetArea() {return Width * Height;}
}

Answer 5

I'd rather implement an interface instead of abstract class and use explicit interface implementation where it's convenient:

public interface IShape {
  ... 
  Double GetArea(Double width, Double height);
}

// Abstract class
// It's redundant and here is because it required by the task
public abstract class Shape: IShape {
}

public class Oval: Shape {
  ...
  public Double GetArea(Double width, Double height) {
    return Math.PI * width * height / 4; 
  }
}

public class Circle: Shape {
  ...
  // This method's more convenient
  public Double GetArea(Double diameter) {
    return Math.PI * diameter * diameter * 4;
  }

  // Explicit interface implementation: 
  // We have to implement two arguments method
  // however, it's combersome that's why we hide it under
  // explicit interface implementation
  Double IShape.GetArea(Double width, Double height) {
    return this.GetArea(width / 2);
  }
}