feat: Add GetAndSet class demonstrating encapsulation with getters and setters

WHAT the code does:
- Defines `Person2` class with **private fields**:
  - `name` (String)
  - `age` (int)
- Provides public getter and setter methods:
  - `getName()` / `setName(String name)`
  - `getAge()` / `setAge(int age)` with validation (`age > 0`).
- Defines `GetAndSet` class with `main()`:
  - Creates a `Person2` object.
  - Sets valid values (`"John Doe"`, `25`) using setters.
  - Prints values using getters.
  - Attempts to set invalid age (`-5`) → prints validation message.

WHY this matters:
- Demonstrates **encapsulation**, a core OOP principle.
- Shows how getters and setters control access to private fields.
- Illustrates **data validation** in setters to ensure object integrity.

HOW it works:
1. `p.setName("John Doe")` → assigns name.
2. `p.setAge(25)` → valid, assigns age.
3. `getName()` and `getAge()` print values.
4. `p.setAge(-5)` → fails validation, prints `"Age must be positive."`.

Tips & gotchas:
- Always keep fields private to enforce controlled access.
- Setter validations prevent invalid state in objects.
- Getter/setter names follow JavaBean conventions, useful for frameworks (e.g., Spring).
- Can extend validation (e.g., `maxAge` limit, null/empty name check).

Use-cases:
- Educational example for **encapsulation and access control**.
- Basis for modeling domain entities with controlled state.
- Prepares for frameworks relying on JavaBean properties.
- Helps enforce business rules at the object level.

Short key: class-get and set-encapsulation-validation.

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

Author: Someshdiwan

Section10Methods/src/GetAndSet.java

@@ -1,26 +1,3 @@
-/*
-Getter and Setter Methods in Java
-
-In Java, getter and setter methods are used to access and modify private fields of a class.
-They are part of the encapsulation principle in Object-Oriented Programming (OOP), ensuring that the internal representation of a class is hidden from outside access
-
-
-1. Why Use Getters and Setters?
-Encapsulation & Data Hiding
-Encapsulation helps in restricting direct access to class fields.
-Fields are typically marked as private, preventing external modification.
-Getters allow controlled read access, and setters provide controlled write access.
-Data Validation
-Setters can include validation logic to prevent invalid data from being set.
-Read-Only or Write-Only Access
-A class may provide a getter without a setter (making it read-only).
-A class may provide a setter without a getter (making it write-only).
-Logging & Debugging
-You can log every time a field is accessed or modified.
-Helps in tracking changes to data.
-*/
-
-// Person2 class: Represents an individual with name and age
 class Person2 {
     private String name;  // Private variable
     private int age;      // Private variable
@@ -43,15 +20,14 @@ public int getAge() {
     // Setter method for age with validation
     public void setAge(int age) {
         if (age > 0) {
-            // Ensuring valid age
+            // Ensuring valid age.
             this.age = age;
         } else {
             System.out.println("Age must be positive.");
         }
     }
 }
 
-// Main class: To run the application
 public class GetAndSet {
     public static void main(String[] args) {
         Person2 p = new Person2();
@@ -61,27 +37,64 @@ public static void main(String[] args) {
         p.setAge(25);
 
         // Using getter methods
-        System.out.println("Name: " + p.getName()); // Output: Name: John Doe
-        System.out.println("Age: " + p.getAge());   // Output: Age: 25
+        System.out.println("Name: " + p.getName());
+        System.out.println("Age: " + p.getAge());
 
         // Attempting to set invalid age
-        p.setAge(-5);  // Output: Age must be positive.
+        p.setAge(-5);
     }
 }
 
 /*
+Getter and Setter Methods in Java:
+In Java, getter and setter methods are used to access and modify private fields of a class.
+They are part of the encapsulation principle in Object-Oriented Programming (OOP),
+ensuring that the internal representation of a class is hidden from outside access.
+
+1. Why Use Getters and Setters?
+Encapsulation & Data Hiding.
+Encapsulation helps in restricting direct access to class fields.
+Fields are typically marked as private, preventing external modification.
+Getters allow controlled read access, and setters provide controlled write access.
+
+Data Validation:
+
+Setters can include validation logic to prevent invalid data from being set,
+Read-Only or Write-Only Access.
+
+A class may provide a getter without a setter (making it read-only).
+A class may provide a setter without a getter (making it write-only).
+
+Logging & Debugging:
+You can log every time a field is accessed or modified.
+Helps in tracking changes to data.
+
 Key Points:
-Encapsulation: The name and age fields are private, meaning they cannot be accessed directly outside of the Person2 class. The getter and setter methods provide controlled access.
-Data Validation: The setAge() method includes a validation check to ensure the age is positive before it’s set. This prevents invalid data from being assigned to the age field.
-Read-Write and Write-Only Access: In this example, the name field has both a getter and a setter, allowing both read and write access. The age field also provides both getter and setter methods, with the setter including validation to ensure the data is appropriate.
-Logging and Debugging: Although you haven't explicitly added logging, this pattern allows for logging in setter methods. For instance, you could log whenever the setName() or setAge() methods are called.
+Encapsulation: The name and age fields are private, meaning they cannot be accessed directly outside the Person2 class.
+The getter and setter methods provide controlled access.
+
+Data Validation: The setAge() method includes a validation check to ensure the age is positive before it’s set.
+This prevents invalid data from being assigned to the age field.
+
+Read-Write and Write-Only Access: In this example, the name field has both a getter and a setter,
+allowing both read and write access.
+The age field also provides both getter and setter methods, with the setter including validation to ensure the data is appropriate.
+
+Logging and Debugging: Although you haven't explicitly added logging, this pattern allows for logging in setter methods.
+For instance, you could log whenever the setName() or setAge() methods are called.
 
 Fixing the Code:
-There’s a small issue with the code structure: the Person2 class is inside the GetAndSet class. It would be better to move it outside the GetAndSet class to ensure that it works as expected. Additionally, Main should be outside GetAndSet.  Explanation of Changes:
+There’s a small issue with the code structure: the Person2 class is inside the GetAndSet class.
+It would be better to move it outside the GetAndSet class to ensure that it works as expected.
+Additionally, Main should be outside GetAndSet.
+
+Explanation of Changes:
 Class Structure: Person2 is now a top-level class, making it clearer and ensuring proper structure for the program.
 Usage of Main class: The Main class is now separate and contains the main() method to run the code.
 What You Can Do with Getters and Setters:
 Validation: Ensure that data entered is valid (like with setAge()).
 Logging: Track changes to an object’s state for debugging or auditing purposes.
-Control Access: You can provide read-only properties by omitting the setter, or write-only properties by omitting the getter, depending on your needs.
-*/
+
+Control Access: You can provide read-only properties by omitting the setter, or
+write-only properties by omitting the getter, depending on your needs.
+*/