feat: Add Scope class to demonstrate variable scope and shadowing in Java

WHAT the code does:
- Defines a `Scope` class to illustrate how variable scope works in Java.
- Shows that variables declared outside a block can be reassigned inside it.
- Demonstrates block-scoped variables that cannot be accessed outside the block.
- Shows loop-scoped variables (`i` and `num` inside the `for` loop).
- Provides a `random(int marks)` method with its own local scope.

WHY this matters:
- Helps understand **scope, shadowing, and lifetime of variables** in Java.
- Reinforces that variables with the same name cannot be redeclared in the same scope.
- Clarifies the difference between reassignment and re-declaration.
- Teaches best practices for avoiding naming conflicts.

HOW it works:
1. Declares `a`, `b`, and `name` in `main()`.
2. Inside a block:
   - Reassigns `a = 100`.
   - Defines a new block-scoped variable `c = 99`.
   - Changes `name` to `"Rahul"`.
3. After block:
   - Creates a new `c = 900` (different from block’s `c`).
   - Prints updated values of `a`, `name`, and `c`.
4. In the `for` loop:
   - `i` and `num` exist only inside the loop body.
   - `a` is reassigned to `10000` in each iteration.
5. `random()` method:
   - Defines local `num = 67`.
   - Prints both local `num` and parameter `marks`.

Tips & gotchas:
- Attempting to redeclare `a` inside the block would cause a compile error due to shadowing rules.
- Variables declared in a block (`{}`) cannot be accessed outside of it.
- Loop counters and local variables are destroyed once the block exits.
- Good practice: use descriptive names to avoid shadowing confusion.

Use-cases:
- Educational example to teach **variable scope and shadowing**.
- Helps beginners avoid common compile-time errors with redeclaration.
- Foundation for understanding **memory management and lifetime** of variables.
- Useful in debugging scoping issues in larger codebases.

Short key: class-scope-variable-shadowing.

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

Author: Someshdiwan

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

@@ -2,30 +2,33 @@ public class Scope {
     public static void main(String[] args) {
         int a = 10;
         int b = 20;
-        String name = "Kunal";
+        String name = "Determine a scope.";
+
         {
-//                int a = 78; // already initialised outside the block in the same method, hence you cannot initialise again
-                a = 100; // reassign the origin ref variable to some other value
-            System.out.println(a);
-                int c = 99;
-                name = "Rahul";
-            System.out.println(name);
-                // values initialised in this block, will remain in block
+        // int a = 78;
+        // already initialised outside the block in the same method, hence you cannot initialise again.
+
+        a = 100;
+        // reassign the origin ref variable to some other value
+        System.out.println(a);
+
+        int c = 99;
+        name = "Rahul";
+        System.out.println(name);
+        // values initialised in this block, will remain in block
         }
         int c = 900;
         System.out.println(a);
         System.out.println(name);
-//        System.out.println(c); // cannot use outside the block
+        System.out.println(c); // cannot use outside the block
 
-        // scoping in for loops
         for (int i = 0; i < 4; i++) {
-//            System.out.println(i);
+        //  System.out.println(i);
             int num = 90;
             a = 10000;
         }
         System.out.println();
     }
-
     static void random(int marks) {
         int num = 67;
         System.out.println(num);