feat: Add OverridingRules demo with SuperOverride and SubOverride classes

WHAT the code does:
Defines SuperOverride with:
- DisplayOverride(): prints "Super Method Display."
Defines SubOverride extending SuperOverride with:
- Overridden DisplayOverride(): prints "Sub Display."
Defines OverridingRules with main():
- Creates a SuperOverride reference to a SubOverride object → calls overridden method.
- Creates standalone SuperOverride and SubOverride objects and calls methods.
- Demonstrates multiple reference/object combinations.

WHY this matters:
Illustrates **method overriding** and **dynamic method dispatch** in Java:
- When a superclass reference points to a subclass object, the subclass method executes.
Shows how method resolution depends on the actual object type, not just the reference type.
Reinforces that overriding allows specialization of behavior in subclasses.

HOW it works:
SuperOverride s = new SubOverride(); → prints "Sub Display."
SuperOverride s1 = new SuperOverride(); → prints "Super Method Display."
SubOverride s2 = new SubOverride(); → prints "Sub Display."
SuperOverride s3 = new SuperOverride(); → prints "Super Method Display."

Tips and gotchas:
@ Override annotation should be added in SubOverride to ensure proper overriding.
Method naming conventions: use lowerCamelCase (displayOverride) for clarity.
This example uses identical method signatures—overriding requires same name, parameters, and return type.
Overloading (different parameters) is different from overriding (same signature, different behavior).

Use-cases:
Educational example of overriding rules in OOP.
Foundation for learning polymorphism and runtime behavior resolution.
Useful stepping stone for exploring abstraction and interface-based polymorphism.

Short key: class-superoverride suboverride method-overriding dynamic-dispatch.

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

Author: Someshdiwan

Section12Inheritance/src/OverridingRules.java

@@ -1,13 +1,11 @@
 class SuperOverride{
-    public void DisplayOverride()
-    {
+    public void DisplayOverride() {
         System.out.println("Super Method Display.");
     }
 }
-class SubOverride extends SuperOverride{
 
-    public void DisplayOverride()
-    {
+class SubOverride extends SuperOverride{
+    public void DisplayOverride() {
         System.out.println("Sub Display.");
     }
 }
@@ -25,22 +23,21 @@ public static void main(String[] args) {
 
         SuperOverride s3=new SuperOverride();
         s3.DisplayOverride();
-
     }
 }
 
 /*
 Explanation:
 Method Overriding:
 
-The method DisplayOverride() is now public in both SuperOverride and SubOverride, which allows proper method overriding.
+The method DisplayOverride() is now public in both SuperOverride and SubOverride, which allow proper method overriding.
 Since the method signature remains the same, dynamic method dispatch (runtime polymorphism) occurs.
 
 Dynamic Method Dispatch (Runtime Polymorphism):
 
 The reference variable s is of type SuperOverride, but it is assigned an object of SubOverride (SuperOverride s = new SubOverride();).
-At runtime, Java determines that the actual object is of type SubOverride, so it calls DisplayOverride() of SubOverride, not SuperOverride.
+At runtime, Java determines that the actual object is of the type SubOverride, so it calls DisplayOverride() of SubOverride, not SuperOverride.
 
 Correct Method Invocation:
 s.DisplayOverride(); correctly calls the overridden method in SubOverride.
-*/
+*/