feat: Demonstrate static vs local variable behavior across multiple method calls [static-local-scope]

🔑 Key: static-local-scope
🧠 Logic:
- `static int a = 10`: A class-level variable shared across all instances; retains value across method calls.
- `int b = 10`: A method-local variable, freshly created on each method call.
- Method `fun()` prints `a` and `b`, then increments both.
  - `++a`: Affects the shared static value (persistent across calls).
  - `++b`: Affects the temporary local value (discarded after each call).

📌 Observations:
- First call to `fun()` → prints `10 10`, then increments `a` to `11`.
- Second call → prints `11 10`, because `a` retained its value while `b` re-initialized.

🎯 Concept Reinforced:
- Difference between static and local variables:
  - Static memory: One copy shared → used when persistence is needed.
  - Local stack memory: Temporary → used for short-lived calculations or logic.

📚 Learning Use:
- Clarifies variable scope and lifetime.
- Useful for understanding memory model, especially in OOP design and interview questions.

Signed-off-by: Somesh diwan <[email protected]>

Author: Someshdiwan

Section10Methods/LocalandGlobalVariables/src/StaticVariableDemo.java

@@ -0,0 +1,33 @@
+public class StaticVariableDemo {
+
+    // 🔁 Static variable: belongs to the class, only one copy shared across all instances
+    static int a = 10;
+
+    void fun() {
+        // 🔁 Local variable: created fresh every time the method is called
+        int b = 10;
+
+        // Print current values of a (static) and b (local)
+        System.out.println(a + " " + b);
+
+        // 🔼 ++a updates the shared static value, persists across calls
+        ++a;
+
+        // 🔁 ++b updates the local variable, but b is destroyed after method ends
+        ++b;
+    }
+
+    public static void main(String[] args) {
+        StaticVariableDemo s = new StaticVariableDemo();
+
+        // ✅ First call to fun()
+        // a = 10 → printed, then incremented to 11
+        // b = 10 → printed, then dies after the method ends
+        s.fun();
+
+        // ✅ Second call to fun()
+        // a = 11 (static retains value) → printed, then incremented to 12
+        // b = 10 (new local copy) → printed again, dies again
+        s.fun();
+    }
+}