feat: Demonstrate use of this vs explicit object reference in setters

WHAT the code does:
- Defines class Human with private fields:
  - int age
  - String name
- Provides getters: getAge() and getName().
- Provides two styles of setters:
  - Current version: `SetAge(int age, Human obj)` assigns age to a passed Human object reference (`obj1.age = age`).
  - Alternative (commented): `SetAge(int a)` uses `this.age = a;`, assigning to the current object.
  - setName(String name) sets the current object’s name using `this.name = name;`.
- Main class This:
  - Creates Human object obj.
  - Calls obj.SetAge(30, obj), passing itself to assign age = 30.
  - Calls obj.setName("Reddy").
  - Prints “Reddy : 30”.

WHY this matters:
- Demonstrates difference between:
  - Using `this` → refers to the current object instance on which the method is invoked.
  - Passing an object reference as parameter → modifies whichever object is passed in.
- Shows why **setters usually use `this`**: it avoids the need to pass the object itself.
- Illustrates encapsulation by keeping fields private and exposing getters/setters.

HOW it works:
1. Human obj = new Human().
2. obj.SetAge(30, obj) assigns 30 to the obj’s age field through parameter reference.
3. obj.setName("Reddy") assigns "Reddy" to obj’s name.
4. Printing → "Reddy : 30".

Tips and gotchas:
- Standard setter pattern in Java is `this.field = parameter;`.
- Passing the object into its own setter is redundant and unconventional.
- If method parameter has same name as field, `this.field = field;` disambiguates.
- Using `this` improves clarity and avoids bugs where local variables shadow instance variables.

Use-cases / analogies:
- Think of `this` like saying “me, myself” — when you want to update your own details, you don’t hand yourself in as a parameter.
- Passing object explicitly is like writing your name on a note and giving it back to yourself, then using that note to update your records — possible, but unnecessary.

Short key: java this-keyword setter encapsulation parameter-vs-instance disambiguation.

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

Author: Someshdiwan

Section16StaticFinal/src/This.java

@@ -1,18 +1,15 @@
-class Human
-{
-
+class Human {
     private int age;
     private String name;
 
-    public int getAge()
-    {
+    public int getAge() {
         return age;
     }
-    public void SetAge(int age, Human obj)
-    {
+
+    public void SetAge(int age, Human obj) {
         //Human obj1=new Human();
-        Human obj1=obj;
-        obj1.age=age;
+        Human obj1 = obj;
+        obj1.age = age;
         //this.age=age;
     }
 
@@ -21,13 +18,11 @@ public void SetAge(int age, Human obj)
 //		age=a;
 //	}
 
-
-    public String getName()
-    {
+    public String getName() {
         return name;
     }
-    public void setName(String name)
-    {
+
+    public void setName(String name) {
         this.name=name;
     }
 
@@ -39,8 +34,7 @@ public void setName(String name)
 }
 
 public class This {
-    public static void main(String[] args) throws ClassNotFoundException
-    {
+    public static void main(String[] args) throws ClassNotFoundException {
         Human obj=new Human();
 
         obj.SetAge(30,obj);
@@ -49,6 +43,5 @@ public static void main(String[] args) throws ClassNotFoundException
 
 //		System.out.println(obj.abc()+" : "+obj.getAge());
         System.out.println(obj.getName()+" : "+obj.getAge());
-
     }
-}
+}