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

Explanation

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

At its core, the program simulates a simple payment processing system.

1. Payment Class: This is the base class, representing a generic payment. It has a method processPayment that prints a generic message indicating a payment is being processed.
2. CreditCard Class: This class extends (inherits from) Payment. It overrides the processPayment method to provide specific logic for credit card payments, including a transaction fee.
3. UPI Class: Similar to CreditCard, this class also extends Payment and overrides the processPayment method. It implements payment processing specific to UPI (Unified Payments Interface), printing a message about redirecting to UPI.
4. OwnMethodOverride Class: This is the main class where the program execution begins.
   • It declares a reference variable myTransaction of type Payment. This is crucial because Payment is the superclass.
   • First, myTransaction is assigned an object of CreditCard. When myTransaction.processPayment(100.0) is called, even though myTransaction is declared as a Payment type, the Java Virtual Machine (JVM) at runtime determines that the actual object it refers to is a CreditCard object. Therefore, the processPayment method from the CreditCard class is executed. This is Dynamic Method Dispatch.
   • Next, myTransaction is reassigned to an object of UPI. When myTransaction.processPayment(50.0) is called again, the JVM, at runtime, sees that myTransaction now refers to a UPI object, and thus the processPayment method from the UPI class is executed.

In essence, the program shows how a single reference variable (myTransaction) can refer to different types of objects (CreditCard, UPI) that share a common supertype (Payment), and how the correct overridden method is invoked automatically at runtime based on the actual object's type.

Algorithm

The program follows these steps:

1. Define Base Class: Create a Payment class with a generic processPayment method.
2. Define Subclasses:
   • Create a CreditCard class that extends Payment.
   • Override the processPayment method in CreditCard to include specific logic for credit card payments (e.g., adding a fee).
   • Create a UPI class that extends Payment.
   • Override the processPayment method in UPI to include specific logic for UPI payments.
3. Main Execution:
   • In the main method, declare a reference variable myTransaction of the base class type (Payment).
   • First Scenario:
     • Instantiate a CreditCard object.
     • Assign this CreditCard object to the myTransaction reference.
     • Call the processPayment method using myTransaction, passing an amount (e.g., 100.0).
     • The JVM dynamically dispatches the call to the processPayment method of the CreditCard class.
   • Second Scenario:
     • Instantiate a UPI object.
     • Assign this UPI object to the same myTransaction reference, effectively changing the object it points to.
     • Call the processPayment method using myTransaction, passing a different amount (e.g., 50.0).
     • The JVM dynamically dispatches the call to the processPayment method of the UPI class.