feat: demonstrate method overriding with @OverRide in abstract and concrete classes

WHAT was added:
- Created abstract class `Parent1` with an abstract method `display()`.
- Implemented `Child2` class that extends `Parent1` and provides its own `display()` method.
- Created regular class `Parent` with a concrete `display()` method.
- Implemented `Child` class that extends `Parent` and overrides the `display()` method.
- Added `Main` class to test both abstract and regular inheritance scenarios.

KEY LEARNINGS:
1. Abstract Class & Abstract Method:
   - Abstract classes can contain abstract methods (only signature, no body).
   - Any subclass must implement all abstract methods.
   - Example: `Parent1` → `Child2` implements `display()`.

2. @OverRide Annotation:
   - Ensures the child method correctly overrides the parent method.
   - If the method signature mismatches (e.g., typo), the compiler throws an error.
   - Improves code readability and prevents silent bugs.

3. Concrete Parent with Overridable Methods:
   - Normal classes can define methods that subclasses may override.
   - Example: `Parent.display()` → overridden by `Child.display()`.

4. Polymorphism (Dynamic Method Dispatch):
   - Reference type is parent, but actual object type decides which method executes.
   - `Parent1 obj1 = new Child2();` → Calls Child2’s implementation.
   - `Parent obj2 = new Child();` → Calls Child’s implementation.

REAL-WORLD APPLICATIONS:
- ✅ Framework Design: Abstract classes define contracts, subclasses provide concrete implementations.
- ✅ API Evolution: Base classes provide default implementations, subclasses override where needed.
- ✅ Polymorphism in OOP: Enables writing flexible, reusable, and extensible code.
- ✅ Error Prevention: @OverRide guarantees correctness in method overriding.

RULE OF THUMB:
- Use abstract classes when you want to enforce a contract but also share partial implementation.
- Always use `@Override` when overriding methods for safety and clarity.
- Override concrete methods only if the subclass requires different behavior.

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

Author: Someshdiwan

Section21AnnotationsandJavaDoc/src/Main.java

@@ -0,0 +1,69 @@
+// Abstract Parent class with an abstract method
+abstract class Parent1 {
+    // Abstract method (must be implemented by child classes)
+    abstract public void display();
+}
+
+// Child class that overrides the abstract method
+class Child2 extends Parent1 {
+    @Override
+    public void display() {
+        System.out.println("Child2 implementation of display()");
+    }
+}
+
+// Regular Parent class with a concrete method
+class Parent {
+    public void display() {
+        System.out.println("Parent display method");
+    }
+}
+
+// Child class that overrides the display() method
+class Child extends Parent {
+    @Override
+    public void display() {
+        System.out.println("Child implementation of display()");
+    }
+}
+
+// Main class to test
+public class Main {
+    public static void main(String[] args) {
+        // Test abstract inheritance
+        Parent1 obj1 = new Child2();
+        obj1.display();
+
+        // Test regular inheritance
+        Parent obj2 = new Child();
+        obj2.display();
+    }
+}
+
+/*
+1. abstract class + abstract method
+   - Abstract class ke andar abstract method declare hota hai (sirf signature, body nahi hoti).
+   - Har child class ko us abstract method ko implement karna mandatory hota hai.
+   - Example: Parent1 ke andar `display()` abstract hai → Child2 ne usko override karke body di.
+
+2. @Override annotation
+   - Jab child class parent class ke method ko override karti hai,
+     tab @Override lagane se compiler check karega ki method correctly override hua hai ya nahi.
+   - Agar signature galat likha, to compiler error dega.
+   - Isse bugs avoid hote hain.
+
+3. Concrete Parent class
+   - Agar parent class ke method already defined hain (non-abstract),
+     to child class us method ko override kar sakti hai.
+   - Example: Parent class ka `display()` → Child ne apna `display()` implement kiya.
+
+4. Polymorphism in action
+   - `Parent1 obj1 = new Child2();` → Abstract parent reference, but runtime pe Child2 ka method call hoga.
+   - `Parent obj2 = new Child();` → Normal parent reference, runtime pe Child ka method call hoga.
+   - Ye hi runtime polymorphism / dynamic method dispatch ka example hai.
+
+5. Key Point:
+   - Abstract method override karna mandatory hai.
+   - Normal method override karna optional hai (agar behavior change karna ho to).
+   - @Override annotation lagana best practice hai.
+*/