Inheritance in Java

Explanation

This Java code demonstrates the fundamental object-oriented programming (OOP) concept of inheritance, along with method overriding and polymorphism.

1. Base Class Shape: It defines a general Shape class with a single method calculateArea(). This method provides a generic message, indicating that a "generic Shape" doesn't have a specific area calculation. This class acts as the blueprint or superclass for more specific shapes.

2. Subclasses Square, Rectangle, Circle: These classes extend the Shape class. This means they inherit all the public and protected members (methods and fields) of Shape.

   • Each subclass introduces its own specific instance variables (e.g., side for Square, length and width for Rectangle, radius for Circle) and a constructor to initialize these variables.
   • Crucially, each subclass provides its own implementation of the calculateArea() method. This is called method overriding, where a subclass provides a specific implementation for a method that is already defined in its superclass.

3. Main Class Q6Main: This class contains the main method, which is the entry point of the program.

   • Inside main, objects of the subclasses (Square, Rectangle, Circle) are created.
   • These objects are then assigned to reference variables of the Shape type (e.g., Shape mySquare = new Square(5);). This is a key aspect of polymorphism (meaning "many forms"). A Shape reference can point to any object that is a Shape or a subclass of Shape.
   • When calculateArea() is called on these Shape reference variables (e.g., mySquare.calculateArea();), Java's runtime system determines the actual type of the object (e.g., Square in mySquare) and executes the calculateArea() method specific to that actual object type, not the calculateArea() from the Shape class. This mechanism is known as dynamic method dispatch or runtime polymorphism.

In essence, the code sets up a hierarchy where general shape behavior is defined, and specific shapes provide their unique implementations for that behavior, all managed through a common interface (Shape class and its calculateArea method).

Algorithm

The program follows these steps:

1. Define a Superclass: Create a class Shape with a generic method calculateArea() that prints a placeholder message.
2. Define Subclasses:
   • Create Square, Rectangle, and Circle classes.
   • Each subclass extends the Shape class, establishing an inheritance relationship.
   • Each subclass declares specific instance variables required for its shape (e.g., side for Square, length and width for Rectangle, radius for Circle).
   • Each subclass includes a constructor to initialize its instance variables.
   • Each subclass overrides the calculateArea() method inherited from Shape to provide the correct area calculation and print statement for that specific shape.
3. Instantiate and Demonstrate Polymorphism:
   • In the main method of Q6Main class:
     • Create an object of Square and assign it to a Shape reference variable (mySquare).
     • Create an object of Rectangle and assign it to a Shape reference variable (myRectangle).
     • Create an object of Circle and assign it to a Shape reference variable (myCircle).
4. Invoke Overridden Methods:
   • Call the calculateArea() method on each of the Shape reference variables (mySquare, myRectangle, myCircle).
   • Observe that the specific calculateArea() implementation of the actual object type (e.g., Square's calculateArea(), not Shape's) is executed at runtime.