feat: Explain why this.itemNo = itemNo; is necessary in constructors when parameter names shadow fields

WHAT the explanation does:
- Shows the common pitfall in constructors when local parameter names are identical to instance variable names.
- Demonstrates incorrect code (`itemNo = itemNo;`) where the local variable assigns itself and the instance field remains uninitialized.
- Shows correct usage (`this.itemNo = itemNo;`) where `this.itemNo` explicitly refers to the instance variable and assigns it the constructor parameter.
- Provides runnable examples illustrating the difference: one prints `null` (incorrect), the other prints "A25" (correct).

WHY this matters:
- Highlights the importance of the `this` keyword in **disambiguating scope**.
- Without `this`, constructor parameters shadow instance variables, leaving them unchanged.
- Understanding this prevents subtle initialization bugs where objects appear to be created but fields remain `null` or default values.
- It’s a cornerstone of clean Java class design and a best practice when parameter names intentionally mirror field names.

HOW it works:
1. **Incorrect case**:
   - Constructor parameter `itemNo` shadows the instance variable of the same name.
   - Statement `itemNo = itemNo;` assigns the parameter to itself, leaving the instance variable unmodified (`null`).
2. **Correct case**:
   - `this.itemNo` refers to the class’s instance variable.
   - `this.itemNo = itemNo;` sets the instance variable equal to the constructor parameter.
   - Object state is correctly initialized.

Tips and gotchas:
- Always use `this` when constructor parameters or method parameters share the same name as fields.
- Some developers use naming conventions (like `this.itemNo = itemNo;` vs. `itemNo_` for parameters) to avoid confusion, but `this` is the most direct approach.
- `this` is also useful for method chaining (`return this;`) and passing the current object as a parameter.
- If fields and parameters have different names, `this` is not strictly necessary, but using it consistently can improve clarity.

Use-cases / analogies:
- Think of `this` as saying “my copy of the variable.”
  Example: Two people named John in a room; one says “this John” to make clear he means himself, not the other John.
- In a constructor, the parameter John (`itemNo`) walks in, and you explicitly assign him to “this John’s record” (`this.itemNo`).

Short key: java-this constructor-shadowing variable-assignment disambiguation.

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

Author: Someshdiwan

Section15InnerClasses/src/Solve Delete 2.txt renamed to Section15InnerClasses/src/Why use this in constructor.txt

@@ -1,30 +1,30 @@
-### **Why Do We Need `this.itemNo = itemNo;` in the Constructor?**  
+Why Do We Need `this.itemNo = itemNo;` in the Constructor?
 
-If you **don’t** use `this.itemNo = itemNo;` in the constructor, the instance variable (`itemNo`) **won’t be assigned the value** passed as a parameter.  
+If you don’t use `this.itemNo = itemNo;` in the constructor,
+the instance variable (`itemNo`) won’t be assigned the value passed as a parameter.
 
-#### **What Happens If We Don't Use `this`?**  
-Take a look at this incorrect constructor:  
+What Happens If We Don't Use `this`?
+Take a look at this incorrect constructor:
 
-```java
 public Product(String itemNo) {
     itemNo = itemNo; // ❌ Wrong! This does nothing
 }
-```
-Here, `itemNo = itemNo;` means the **local variable (`itemNo`) is being assigned to itself**.  
-➡️ **This does not change the instance variable.**  
 
-#### **What Happens When We Use `this`?**  
-```java
+Here, `itemNo = itemNo;` means the **local variable (`itemNo`) is being assigned to itself**.
+➡️ This does not change the instance variable.
+
+What Happens When We Use `this`?
+
 public Product(String itemNo) {
     this.itemNo = itemNo; // ✅ Correct! Assigns parameter to instance variable
 }
-```
-- `this.itemNo` refers to the **instance variable** of the class.
-- `itemNo` (without `this`) refers to the **local parameter** passed to the constructor.
+
+- `this.itemNo` refers to the instance variable of the class.
+- `itemNo` (without `this`) refers to the local parameter passed to the constructor.
 - `this.itemNo = itemNo;` assigns the constructor parameter to the instance variable.
 
-### **Example: Without `this` (Incorrect Code)**
-```java
+Example: Without `this` (Incorrect Code):
+
 class Product {
     private String itemNo;
 
@@ -46,13 +46,13 @@ public class Main {
 ```
 🛑 Since the instance variable `itemNo` was **never assigned**, it remains `null`.
 
-### **Example: With `this` (Correct Code)**
-```java
+Example: With `this` (Correct Code):
+
 class Product {
     private String itemNo;
 
     public Product(String itemNo) {
-        this.itemNo = itemNo; // ✅ Correct! Assigns parameter value to instance variable
+        this.itemNo = itemNo;
     }
 
     public String getItemNo() {
@@ -63,12 +63,12 @@ class Product {
 public class Main {
     public static void main(String[] args) {
         Product p = new Product("A25");
-        System.out.println(p.getItemNo()); // ✅ Output: A25 (Correct!)
+        System.out.println(p.getItemNo());
     }
 }
 ```
 🟢 Now, `getItemNo()` returns `"A25"` as expected.
 
-### **Conclusion**
-**When the parameter name is the same as the instance variable name, use `this` to refer to the instance variable.**  
-Without `this`, the assignment **does nothing**, leading to incorrect behavior (like getting `null`).
+Conclusion:
+When the parameter name is the same as the instance variable name, use `this` to refer to the instance variable.
+Without `this`, the assignment does nothing, leading to incorrect behavior (like getting `null`).