docs: Explain use of this keyword for disambiguating constructor parameters

WHAT the update covers:
Adds detailed explanation and examples showing why `this.itemNo = itemNo;` is required in constructors when parameter names shadow instance variables.

WHY this matters:
Clarifies the difference between local parameters and instance variables in Java.
Without `this`, assignments like `itemNo = itemNo;` only reassign the parameter to itself, leaving the instance variable uninitialized (defaulting to null or 0).
Using `this.itemNo` explicitly refers to the object’s field, ensuring correct initialization.

HOW it works:
Incorrect case:
- public Product(String itemNo) { itemNo = itemNo; }
- Creates a Product but leaves the field itemNo null.
Correct case:
- public Product(String itemNo) { this.itemNo = itemNo; }
- Properly assigns the parameter value to the instance variable.
Demonstrated with examples showing null output without `this` vs correct "A25" output with `this`.

Tips and gotchas:
`this` is only required when parameter names shadow instance variables; otherwise, it can be omitted.
Using `this` improves readability and avoids subtle bugs, especially in constructors and setters.
Overusing identical parameter and field names can cause confusion; some developers adopt naming conventions like prefixing fields (e.g., itemNo vs itemNoParam).

Use-cases:
Educational note for beginners learning constructors and `this` keyword.
Prevents common mistakes in object initialization.
Forms the basis for understanding scope resolution in OOP.

Short key: docs-this-keyword constructor-parameter-shadowing.

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

Author: Someshdiwan

Section11ObjectOrientedProgramming/src/Section11ProductAndCostomer.txt renamed to Section11ObjectOrientedProgramming/src/Explain use of `this` keyword.txt

@@ -1,6 +1,7 @@
 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`?
 
@@ -22,6 +23,7 @@ public Product(String itemNo) {
 }
 
 ```
+
 - `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.
@@ -30,16 +32,13 @@ Example: Without `this` (Incorrect Code)
 
 class Product {
     private String itemNo;
-
     public Product(String itemNo) {
         itemNo = itemNo; // ❌ Wrong! This does nothing
     }
-
     public String getItemNo() {
         return itemNo;
     }
 }
-
 public class Main {
     public static void main(String[] args) {
         Product p = new Product("A25");
@@ -72,7 +71,6 @@ public class Main {
 ```
 🟢 Now, `getItemNo()` returns `"A25"` as expected.
 
-Conclusion
-
+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`).
+Without `this`, the assignment does nothing, leading to incorrect behavior (like getting `null`).