feat: Add SwapAnswer class showing mutable array swap and String reassignment

WHAT the code does:
- Defines a `SwapAnswer` class demonstrating how to make swaps and updates persist.
- Uses an **array** to swap integers:
  - `swap(int[] arr)` exchanges `arr[0]` and `arr[1]`.
  - Works because arrays are mutable objects in Java.
- For Strings:
  - `changeName(String naam)` returns a new string.
  - Caller explicitly reassigns `name` to the return value, making the change visible.

WHY this matters:
- Shows how to overcome Java’s **pass-by-value** semantics:
  - Mutable objects (like arrays) allow persistent modifications.
  - Immutable objects (like Strings) require reassignment.
- Reinforces concepts of **mutability vs immutability** in Java.

HOW it works:
1. Array `{10, 20}` passed to `swap()`.
   - After swap → `{20, 10}`.
   - Printing shows `"20 10"`.
2. String `"Swapping numbers"` passed to `changeName()`.
   - Returns new string.
   - Caller assigns it back to `name`.
   - Printing shows updated string message.

Tips & gotchas:
- Arrays provide mutability, but introducing a custom wrapper class could make swaps clearer.
- For Strings, since they are immutable, always return a new value if modification is required.
- Be mindful of side effects: changing arrays inside methods alters caller’s copy too.
- Demonstrates a common interview pitfall: difference between reassigning a reference and mutating an object.

Use-cases:
- Educational example on **mutability and method behavior**.
- Foundation for explaining why wrapper objects (like `AtomicInteger`) are used for pass-by-reference-like behavior.
- Practical in cases where modifications must reflect outside method scope.
- Useful exercise for distinguishing **Java immutability (String)** from **mutability (array)**.

Short key: class-swap answer-array-mutable-string-reassign.

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

Author: Someshdiwan

Section10Methods/Methods 2.O/src/SwapAnswer.java

@@ -0,0 +1,48 @@
+public class SwapAnswer {
+    public static void main(String[] args) {
+        int[] nums = {10, 20};
+        // use array so changes reflect
+        swap(nums);
+        System.out.println(nums[0] + " " + nums[1]);
+
+        String name = "Swapping numbers";
+        name = changeName(name);
+        System.out.println(name);
+    }
+
+    // swap numbers method
+    static void swap(int[] arr) {
+        int temp = arr[0];
+        arr[0] = arr[1];
+        arr[1] = temp;
+        // this change will be valid since array is mutable
+    }
+
+    // change name method
+    static String changeName(String naam) {
+        return "Declaring a method(outside the main method) and called this method inside the main method.";
+    }
+}
+
+/*
+🔹 Why numbers don’t swap:
+In Java, method parameters are always passed by value.
+When you call swap(a, b), the values 10 and 20 are copied into num1 and num2.
+Inside the method, num1 and num2 do swap, but those are just local copies.
+The original a and b in main remain unchanged.
+
+👉 That’s why after the swap call, printing a and b still shows 10 20.
+
+🔹 Why name doesn’t change
+A String in Java is an immutable object (it can’t be modified once created).
+When you pass name to changeName, a copy of the reference is passed.
+Inside the method, you reassign naam to point to a new string, but this doesn’t affect the original name variable in main.
+
+So after the method call, name still points to "Swapping numbers".
+
+👉 That’s why printing name still shows "Swapping numbers".
+
+📌 Summary in one line:
+Primitives like int only swap local copies, and String can’t be changed because it’s immutable and reassigning
+the reference inside a method doesn’t affect the original.
+*/