feat: Add DynamicMethodDispatch example with method overriding and polymorphism

WHAT the code does:
Defines Super with methods:
- meth1(): prints "Super Meth1".
- meth2(): prints "Super Meth2".
Defines Sub extending Super:
- Overrides meth2() to print "Sub Meth2".
- Adds meth3() as a new method.
Defines DynamicMethodDispatch with main():
- Creates a Super reference pointing to a Sub object.
- Calls meth1() and meth2() on the reference, demonstrating polymorphism.

WHY this matters:
Demonstrates dynamic method dispatch (runtime polymorphism) in Java:
- Method calls are resolved at runtime based on the actual object type, not the reference type.
Illustrates method overriding with @OverRide for correctness and clarity.
Shows how subclass-specific methods (like meth3()) cannot be called on a superclass reference.

HOW it works:
Super sup = new Sub();
sup.meth1() → resolved to Super.meth1 → prints "Super Meth1".
sup.meth2() → resolved to Sub.meth2 → prints "Sub Meth2".
sup.meth3() → not allowed, since reference type Super doesn’t define meth3().
If a Sub reference were used directly, meth3() would also be accessible.

Tips and gotchas:
Use @OverRide to catch accidental mistakes in overriding method signatures.
Dynamic method dispatch applies only to overridden methods, not to fields (field access depends on reference type).
System.err is used in Sub.meth2(); this prints to standard error, which may look different from System.out in some consoles.
Polymorphism is powerful for designing flexible systems but can be misused if hierarchies grow unnecessarily deep.

Use-cases:
Educational demonstration of runtime polymorphism in Java.
Foundation for learning abstraction and interface-based designs.
Practical basis for frameworks where behavior is decided at runtime via object type.

Short key: class-super-sub dynamic-method-dispatch polymorphism.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section12Inheritance/src/DynamicMethodDispatch.java

@@ -1,80 +1,87 @@
-class Super
-{
-    public void meth1()
-    {
+class Super {
+    public void meth1() {
         System.out.println("Super Meth1");
     }
 
-    public void meth2()
-    {
+    public void meth2() {
         System.out.println("Super Meth2");
     }
 }
 
-class Sub extends Super
-{
+class Sub extends Super {
     @Override
-    public void meth2()
-    {
+    public void meth2() {
         System.err.println("Sub Meth2");
     }
 
-    public void meth3()
-    {
+    public void meth3() {
         System.out.println("Sub Meth3");
     }
 }
-public class DynamicMethodDispatch
-{
-    public static void main(String[] args)
-    {
+
+public class DynamicMethodDispatch {
+    public static void main(String[] args) {
         Super sup=new Sub();
 
         sup.meth1();
         sup.meth2();
         /*sup.meth3();*/
 
-       /*
+        /*
         Sub sub1=new Sub();
         sub1.meth1();
         sub1.meth2();
         sub1.meth3();
         */
-
-        /*
-        The line Sub sub1 = new Super(); attempts to assign an instance of Super to a reference variable of type Sub. This is not allowed because Super is the parent class of Sub, but Sub is the subclass of Super.
-        In other words, a Super object cannot be assigned to a Sub reference, as it may not have all the methods or behavior that Sub has. The JVM does not know how to handle this assignment safely, so this will not compile.
-
-        Key Takeaway:
-        You cannot assign an instance of the superclass (Super) to a reference of the subclass (Sub).
-        You can assign an instance of the subclass (Sub) to a reference of the superclass (Super) because of upcasting (polymorphism).
-        However, you cannot do the reverse (Super to Sub), as this would cause a downcasting error unless explicitly cast with proper checks.
-        */
     }
 }
 
 /*
-the object sup is of type Super, but it refers to an instance of the Sub class. This is an example of dynamic method dispatch (or runtime polymorphism),
+The line Sub sub1 = new Super(); attempts to assign an instance of Supper to a reference variable of type Sub.
+
+This is not allowed because Supper is the parent class of Sub, but Sub is the subclass of Supper.
+
+In other words, a Super object cannot be assigned to a Subreference, as it may not have all the methods or behavior that
+Sub has.
+
+The JVM does not know how to handle this assignment safely, so this will not compile.
+
+Key Takeaway:
+You cannot assign an instance of the superclass (Super) to a reference of the subclass (Sub).
+You can assign an instance of the subclass (Sub) to a reference of the superclass (Super) because of upcasting (polymorphism).
+However, you cannot do the reverse (Super to Sub), as this would cause a down casting error unless explicitly cast with proper checks.
+
+
+the object sup is of type Super, but it refers to an instance of the Subclass.
+This is an example of dynamic method dispatch (or runtime polymorphism),
 where the actual method invoked depends on the object's actual type, not the reference type.
 
 Here's what's happening in your code:
         sup.meth1();
 
-Since sup is of type Super, the method meth1() is directly called from the Super class. So, it prints "Super Meth1".
+Since sup is of type Super, the method meth1() is directly called from the Super class.
+
+So, it prints "Super Meth1".
         sup.meth2();
-Although the reference type is Super, the actual object is of type Sub. Java looks at the actual type of the object at runtime (which is Sub),
-and invokes the overridden version of meth2() from the Sub class. Thus, it prints "Sub Meth2".
+Although the reference type is Super, the actual object is of type Sub.
+
+Java looks at the actual type of the object at runtime (which is Sub),
+and invokes the overridden version of meth2() from the Sub class.
+
+Thus, it prints "Sub Meth2".
         sup.meth3();
-Even though sup refers to an object of type Sub, the reference type is still Super. The method meth3() is defined only in the Sub class and not in the Super class. Since Super doesn't have a method meth3(),
+Even though sup refers to an object of type Sub, the reference type is still Supper.
+
+The method meth3() is defined only in the Subclass and not in the Super class. Since Supper doesn't have a method meth3(),
 the compiler will give an error when trying to compile the code.
 
 Why does sup.meth3(); give an error?
-The reason for the error is that the reference variable sup is of type Super, and the Super class does not define the meth3() method. Therefore, the compiler cannot resolve meth3() for the sup reference,
-even though the actual object is of type Sub which has the meth3() method.
+The reason for the error is that the reference variable sup is of type Super, and the Super class does not define the meth3() method.
 
+Therefore, the compiler cannot resolve meth3() for the sup reference,
+even though the actual object is of type Sub which has the meth3() method.
 
-sub1.meth1() calls the method from the superclass Super because it is inherited.
-sub1.meth2() calls the overridden method from the subclass Sub due to dynamic method dispatch.
+sub1.meth1() calls the method from the superclass Supper because it is inherited.
+sub1.meth2() calls the overridden method from the subclass Subdue to dynamic method dispatch.
 sub1.meth3() calls the method from Sub, as it is defined in that class.
-
-*/
+*/