Abstract methods

Figure 488. Calculating a shape's area

public class Rectangle extents Shape {
  /**
   * Calculate the area.
   * @return The rectangle's area
   */
  public double getArea() {
    return width * height;
  } ...

public class Circle extents Shape {
  /**
   * Calculate the area.
   * @return The circle's area
   */
  public double getArea() {
    return PI * radius * radius;
  } ...

Figure 489. Desired: Polymorphic getArea() call

final Shape[] shapes ❶ = {
    new Circle(1, 1, 2.) ❷,
    new Rectangle(1, -1, 2., 3.)❷
};

for (final Shape s : shapes) {
  System.out.println(s.toString() + ": area = " + s.getArea()); ❸
}

Circle at (1.0|1.0), radius= 2.0: area = 12.566370614359172
Rectangle at (1.0|-1.0), width= 2.0, height=3.0: area = 6.0

❶	An array of `Shape` references.
❷	A `Rectangle` “is a” `Shape` and likewise is `Circle`. We can thus assign both `Circle` and `Rectangle` instances to variables (or array elements) of type `Shape` by means of upcasting.
❸	Polymorphic dispatch: Depending on the object's type the Java™ runtime will automatically choose either `Rectangle`.`toString()`/ `Rectangle`.`getArea()` or `Circle`.`getArea()` / `Circle`.`toString()`/ `Circle`.`getArea()` respectively.

Figure 490. Problems:

No meaningful getArea() method in class Shape possible.
Meaningful implementations exist both in subclassRectangle and Circle.

Solution: Abstract method getArea() in superclass Shape.

Figure 491. abstract method getArea()

abstract❶ public class Shape {
  /**
   * Calculate the shape's area.
   * @return The shape's area
   */
  abstract❷ public double getArea()❸;
...

public class Rectangle extends Shape {
  @Override❶
  public double getArea() {
    return width * height;
  }
...

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

❶	Superclass `Shape` contains an `abstract` method and must thus itself be declared `abstract` as well. Note You cannot create instances of `abstract` classes. You may however create instances of derived non-`abstract` classes.
❷	Method `getArea()` cannot be implemented in a meaningful way. Its `abstract` modifier is a promise that some concrete (= non-`abstract`) subclass will either offer an implementation of `getArea()` or will have an intermediate parent class doing so. In other words: The `abstract` keyword requires a corresponding implementation in some derived non-`abstract` subclass.
❸	An `abstract` method must not have an implementing body `{...}`.
❶	Both `Rectangle` and `Circle` are concrete (=non-`abstract`) classes and are thus obliged to provide an implementation of `double getArea()`.

Figure 492. abstract method getArea()

‹›

Figure 493. What's a “shape” anyway?

Figure 494. No instances of abstract classes.

final Shape s =
   new Shape(1., 2.); // Error: 'Shape' is abstract; cannot be instantiated

Figure 495. Mandatory getArea() implementation.

// Error: Class 'Circle' must either be declared abstract or
//        implement abstract method 'getArea()' in 'Shape'
public class Circle extends Shape {

  public Circle(double x,double y, double radius) {
    super(x, y);
    this.radius = radius;
  }
  private double radius;
}

Figure 496. Facts about abstract fields, methods and classes.

A class containing an abstract method must itself be declared abstract.
abstract classes are allowed to host non-abstract methods.
A class may be declared abstract irrespective of purely containing non-abstract methods.

Prev	Up	Next
`final` methods	Home	Geometry classes reconsidered

Inheritance

Note