To implement Java Program to demonstrate Method Overriding and Dynamic method dispatch

Explanation

This Java program demonstrates two fundamental object-oriented programming concepts: Method Overriding and Dynamic Method Dispatch (also known as Runtime Polymorphism).

1. Base Class shape: We start by defining a class named shape. This class has a simple method called draw(), which, when invoked, prints "Drawing a shape" to the console. This acts as our generic blueprint for any shape.

2. Derived Classes circle and rectangle:

   • The circle class extends shape. This means circle is a specialized type of shape and inherits all its properties and methods.
   • Crucially, circle also has its own draw() method. Notice the @Override annotation. This indicates that the draw() method in circle is intentionally replacing (overriding) the draw() method inherited from its parent class shape. When circle's draw() is called, it prints "Drawing a circle".
   • Similarly, the rectangle class also extends shape and overrides the draw() method to print "Drawing a rectangle".

3. Main Class and Dynamic Method Dispatch:

   • Inside the main method, we declare a reference variable s of type shape: shape s;. This variable can point to any object that is a shape or a subclass of shape.
   • First Assignment: s = new circle();. Here, we make the shape reference s point to a new circle object. Even though s is declared as a shape, it is currently holding an object of type circle.
   • First Method Call: s.draw();. When this line is executed, Java needs to decide which draw() method to call. Since s currently refers to a circle object, Java's Dynamic Method Dispatch mechanism kicks in. It determines at runtime that the actual object type is circle, and therefore, it calls the draw() method defined in the circle class. The output will be "Drawing a circle".
   • Second Assignment: s = new rectangle();. Now, the same shape reference s is made to point to a new rectangle object. The circle object previously referenced by s is now unreferenced (and subject to garbage collection if no other references exist).
   • Second Method Call: s.draw();. Again, Dynamic Method Dispatch takes place. This time, s refers to a rectangle object, so Java calls the draw() method from the rectangle class. The output will be "Drawing a rectangle".

In essence, the program shows how a single reference variable of a parent class type can be used to invoke different implementations of an overridden method based on the actual object it refers to at runtime.

Algorithm

The algorithm used in this program demonstrates the principles of polymorphism through method overriding and dynamic method dispatch:

1. Define a Base Class: Create a parent class (e.g., shape) with a common method (e.g., draw()) that provides a default or generic implementation.
2. Define Derived Classes: Create multiple child classes (e.g., circle, rectangle) that inherit from the base class.
3. Override Methods: In each derived class, override the common method from the parent class to provide a specialized implementation unique to that derived class. Use the @Override annotation for clarity and compile-time checking.
4. Declare a Polymorphic Reference: In the main method, declare a reference variable of the base class type. This reference can point to objects of the base class or any of its derived classes.
5. Instantiate and Assign Derived Objects:
   • Create an object of the first derived class (e.g., new circle()) and assign it to the base class reference variable.
   • Call the overridden method using this base class reference. Due to dynamic method dispatch, the method implementation of the actual object type (e.g., circle) will be executed at runtime.
6. Reassign and Repeat:
   • Reassign the same base class reference variable to an object of another derived class (e.g., new rectangle()).
   • Call the overridden method again using the same base class reference. The method implementation of this new actual object type (e.g., rectangle) will be executed at runtime.