feat: Add SimpleCalculator class demonstrating method overloading

WHAT the code does:
- Defines a `SimpleCalculator` class with three overloaded `calculate()` methods:
  1. **No parameters** → adds two constants (`7 + 13 = 20`) and prints the result.
  2. **Two parameters** → multiplies two integers and returns the product.
  3. **Three parameters** → subtracts two numbers from the first and prints the result.
- `main()` demonstrates all three variations:
  - Calls no-arg method → prints addition.
  - Calls two-arg method → prints multiplication.
  - Calls three-arg method → prints subtraction.

WHY this matters:
- Demonstrates **method overloading** (same name, different signatures).
- Shows multiple operations (addition, multiplication, subtraction) under a unified method name.
- Reinforces compile-time polymorphism in Java.

HOW it works:
1. `calc.calculate()` → prints `"Addition (no parameters): 20"`.
2. `calc.calculate(4, 5)` → returns `20`, printed as multiplication.
3. `calc.calculate(50, 20, 10)` → computes `20`, prints subtraction result.

Method Signature Notes:
- Java resolves overloading by the **number and type of parameters** at compile time.
- Return type does not affect method selection.

Tips & gotchas:
- Having a method name that does different operations (`add`, `multiply`, `subtract`) under `calculate` can confuse readability.
- For clarity, separate methods with descriptive names may be better in production.
- Method overloading is useful when operations are **similar in purpose**, not unrelated.

Use-cases:
- Educational example for compile-time polymorphism.
- Foundation for building simple calculators or utility classes.
- Interview prep for method overloading and signatures.

Short key: class-simple calculator-method-overloading.

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

Author: Someshdiwan

Section10Methods/PracticeProblems/src/SimpleCalculator.java

@@ -1,27 +1,24 @@
 public class SimpleCalculator {
-
-    // Method 1: No parameters - adds two constants
-    void calculate() //No parameters
-    {
+    // Method 1: No parameters - adds two constants.
+    void calculate() {
         int x = 7, y = 13;
         int sum = x + y;
         System.out.println("Addition (no parameters): " + sum);
     }
 
-    // Method 2: Two parameters - multiplies them and returns result
+    // Method 2: Two parameters - multiplies them and returns result.
     int calculate(int a, int b) {
         return a * b;
     }
 
-    // Method 3: Three parameters - subtracts and prints result
+    // Method 3: Three parameters - subtracts and prints result.
     void calculate(int a, int b, int c) {
         int result = a - b - c;
         System.out.println("Subtraction (three parameters): " + result);
     }
 
     public static void main(String[] args) {
         SimpleCalculator calc = new SimpleCalculator();
-
         calc.calculate();  // Output: Addition (no parameters): 20
 
         int product = calc.calculate(4, 5);  // 4 * 5 = 20