feat: Add DemonstratesMethodOverloading class with multiple add() methods

WHAT the code does:
- Defines `DemonstratesMethodOverloading` with three overloaded `add()` methods:
  1. `add()` → no parameters → adds hardcoded values `3 + 5` and prints result.
  2. `add(int x, int y)` → takes two integers, returns their sum.
  3. `add(int x, int y, int z)` → takes three integers, computes and prints their sum.
- `main()` demonstrates:
  - Calling `add()` with no arguments.
  - Calling `add(int, int, int)` with three integers.
  - Calling `add(int, int)` with two integers and printing the returned result.

WHY this matters:
- Demonstrates **method overloading** in Java (compile-time polymorphism).
- Shows that multiple methods can share the same name if they differ in parameter count or type.
- Highlights both printing and returning results for flexibility.

HOW it works:
1. `obj.add()` → calls no-arg method → prints `8`.
2. `obj.add(12, 45, 67)` → calls three-arg method → prints `124`.
3. `obj.add(100, 45)` → calls two-arg method → returns `145` → printed in `main`.

Method Signature:
- Java uses **number and type of parameters** to decide which method to invoke.
- `add()` → no parameters → calls the first method.
- `add(int x, int y)` → exactly two integers → calls the second method.
- `add(int x, int y, int z)` → three integers → calls the third method.

Compile-time Resolution:
- Method choice is made at compile time based on the **method signature**.

Return Type is Ignored:
- Java does not consider return type when overloading — only parameters matter.

✅ Summary:
- Method overloading allows multiple methods with the same name but different parameters.
- Useful for providing **flexible ways to perform similar operations** without inventing new method names.

Use-cases:
- Calculator utilities with multiple input forms.
- Simplifying APIs by grouping related operations.
- Educational demonstration of compile-time polymorphism.

Short key: class-methodover loading-add-demo.

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

Author: Someshdiwan

Section10Methods/PracticeProblems/src/HardCodes11.java renamed to Section10Methods/PracticeProblems/src/DemonstratesMethodOverloading.java

@@ -1,48 +1,44 @@
-/*
-Can you write a Java class from scratch that demonstrates method overloading for an add() method?
-
-The class should include:
-
-A method add() with no parameters that adds two hardcoded numbers and prints the result.
-A method add(int x, int y) that returns the sum of two integers.
-A method add(int x, int y, int z) that prints the sum of three integers.
-A main method where you create an object of the class and call all three overloaded methods with sample inputs.
-Bonus: Explain how Java determines which overloaded method to call.
-*/
-
-class HardCodes11
-{
-    void add() //No Parameters.
-    {
+class DemonstratesMethodOverloading {
+    //No Parameters.
+    void add() {
         int a, b, c;
         a=3;
         b=5;
         c=a+b;
         System.out.println(c);
     }
 
-    int add(int x, int y) //Two Parameters.
-    {
+    //Two Parameters.
+    int add(int x, int y) {
         int z;
         z=x+y;
         return z;
     }
 
-    void add(int x, int y, int z) //Three Parameters.
-    {
+    //Three Parameters.
+    void add(int x, int y, int z) {
         int m = x+y+z;
         System.out.println(m);
     }
 
     public static void main(String[] args) {
-        HardCodes11 obj = new HardCodes11();
-
+        DemonstratesMethodOverloading obj = new DemonstratesMethodOverloading();
         obj.add();
-        int num;
 
+        int num;
         obj.add(12,45,67);
         num = obj.add(100,45);
-
         System.out.println(num);
     }
 }
+
+/*
+Can you write a Java class from scratch that demonstrates method overloading for an add() method?
+
+The class should include:
+A method add() with no parameters that adds two hardcoded numbers and prints the result.
+A method add(int x, int y) that returns the sum of two integers.
+A method add(int x, int y, int z) that prints the sum of three integers.
+A main method where you create an object of the class and call all three overloaded methods with sample inputs.
+Bonus: Explain how Java determines which overloaded method to call.
+*/