feat: Add comprehensive guide on static keyword, memory allocation, and static vs instance members in Java

WHAT the document covers:
- Clear definitions and distinctions:
  - Reference vs Object vs Instance: explains `Person p = new Person()` semantics (reference on stack, object on heap, instance meaning).
  - Static (class) variables and methods vs instance variables and methods: what they are, where they live, and how they behave.
- Practical examples for each concept:
  - `Counter` example for static counters.
  - `Person` example for instance vs static fields.
  - `MathUtil` and `Math.sqrt()` as canonical static method usage.
- Where `static` can appear:
  - Variables, static initialization blocks, methods, and static nested classes.
- When memory is allocated:
  - Class loading → static initialization; distinction between stack, heap, and class area.
- Static block vs non-static (instance) block behavior and execution order (static blocks run at class load time; instance blocks run before constructors for each object).
- Rules & restrictions:
  - Static methods cannot access instance members or use `this`/`super`.
  - Initialization requirements for final/static fields.
- Practical tips, caveats, and interview-ready edge cases (naming, access patterns, thread-safety, persistence of static data).

WHY this matters:
- Understanding `static` is essential for correct program design, memory reasoning, and preventing subtle bugs:
  - Prevents accidental shared-state bugs (one instance mutates a static field others see).
  - Helps design singletons, caches, configuration holders, and utility classes correctly.
  - Clarifies lifecycle and initialization timing (useful for avoiding NPEs and understanding startup behavior).
- Prepares developers for common interview questions and real-world decisions (when to use static vs instance).

HOW it works (concise mechanics):
1. Class loading phase:
   - JVM loads `.class`, executes static initialization blocks and assigns memory for static fields (class area / method area).
2. Object creation:
   - `new` allocates on the heap; instance initializers and constructors run; instance fields get their own copies.
3. Access semantics:
   - `ClassName.staticMember` → single shared value or operation.
   - `object.instanceMember` → per-object state and behavior.
4. Static methods:
   - Executed without an instance; can only directly operate on static data or objects passed explicitly.
5. Visibility & lifetime:
   - Static data lives as long as the class is loaded (usually until classloader unload or JVM exit).

TIPS & GOTCHAS (practical, opinionated, and interview-friendly):
- Prefer `ClassName.staticField` over `obj.staticField` for readability and to avoid confusion.
- Use `static` for true shared state or stateless utility functions; avoid it for instance-specific concerns.
- For counters/IDs across program restarts, persist to storage — static variables reset when JVM restarts.
- Thread-safety: static mutable state requires synchronization or concurrent data structures (e.g., `AtomicInteger`, `ConcurrentHashMap`, `volatile` with double-checked locking).
- Initialization order traps: static blocks run once; instance blocks run per-object—beware of depending on static initialization when constructing objects from other classes.
- Avoid the “constant interface” anti-pattern (don’t expose constants by `interface Constants { ... }` unless it represents a true contract).
- Use `final` with static for constants: `public static final double PI = 3.14159;`.
- For utility-only classes, consider `final class Utils { private Utils(){} /* static helpers */ }` to prevent instantiation.
- For nested classes: prefer `static class` when it doesn’t need an outer instance; otherwise use non-static inner class.

REAL-WORLD USE CASES & ANALOGIES:
- Shared scoreboard (static) vs player scorecards (instance).
- Global configuration or singleton resource (static holder) vs per-session or per-user data (instance).
- Static block: one-time factory setup (like loading config) before any code uses the class.
- Instance block: per-object plumbing (like initializing per-connection buffers) that runs before constructor body.

SHORT KEY (tags for search/commit): java static keyword class-vs-instance memory-classloader static-block instance-block thread-safety best-practices.

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

Author: Someshdiwan

Section16StaticFinal/src/Static.txt renamed to Section16StaticFinal/src/static vs instance members in Java.md

@@ -1,33 +1,35 @@
-Below is the generated theory and code exactly as discussed:
+### 1) What is a use static keyword in Java?
 
----
-
-### 1) What is use static keyword in Java?
-
-**Use of static keyword:**  
+Use of static keyword:
 When we are using the static keyword with a variable, block, or method, it becomes independent of the object.  
+
 For example:
+
 ```java
 class Example {
     static int a = 5;
 }
 ```
-Here, `a` is not dependent on any object. If we have two objects (e.g., `obj1` and `obj2`), both objects are able to access this variable. When we use static, it becomes independent of the object.
+
+Here, `a` is not dependent on any object. If we have two objects (e.g., `obj1` and `obj2`),
+both objects are able to access this variable. When we use static, it becomes independent of the object.
 
 ---
 
-### 2) At which place we can use static keyword
+### 2) At which place we can use static keyword:
 
 Four places where we can use the static keyword:
 
-a) **Before variable declaration**  
+a) Before variable declaration:
+
 ```java
 class Calc {
     static int s;
 }
 ```
 
-b) **Before a block**  
+b) Before a block:
+
 ```java
 class Calc {
     static {
@@ -36,14 +38,16 @@ class Calc {
 }
 ```
 
-c) **During method creation**  
+c) During method creation:
+
 ```java
 class Calc {
     public static void add(int num1, int num2) { }
 }
 ```
 
-d) **With the concept of inner class** *(It is not discussed in this lecture)*  
+d) With the concept of inner class (It is not discussed in this lecture):
+
 ```java
 class OuterClass {
     int x = 10;
@@ -55,7 +59,7 @@ class OuterClass {
 
 ---
 
-### 3) When memory get allocated
+### 3) When memory gets allocated:
 
 For that we need to know some terms:  
 a) Stack area  
@@ -73,8 +77,8 @@ c) Class loader system
 
 ```java
 class Calc {
-    static int stA = 100; // independent of object; can be used by class name as well as object
-    int inB = 100;        // dependent on object; can only be used by object
+    static int stA = 100; // independent of an object; can be used by class name as well as object
+    int inB = 100;        // dependent on an object; can only be used by an object
 
     public static void main(String[] args) {
         Calc obj1 = new Calc(); 
@@ -104,10 +108,10 @@ class Calc {
 
 ---
 
-### 5) Static block vs non static block
+### 5) Static block vs. non-static block
 
 - **Static block:** Executed before the execution of the `main` method.
-- **Non static block:** Executed when you create an object and is executed before the constructor is called.
+- **Non-static block:** Executed when you create an object and is executed before the constructor is called.
 
 ```java
 class Calc {
@@ -139,28 +143,25 @@ class Help {
     }
 }
 
-/*
 Output:
 Static Block
-Executed before main
+Executed before
 main method
-Non static block executed before the execution of constructor
+Non-static block executed before the execution of constructor
 Static block of Help class
 Hello
-*/
+
 ```
 
 ---
 
-### 6) Static method vs non static method
+### 6) Static method vs non-static method:
 
 - **Static methods** can be called with an object reference or class name, e.g., `ClassName.staticMethod()` or `objReference.staticMethod()`.
 - **Non static methods** are dependent on the object and can be called only by the object reference, e.g., `objReference.nonStaticMethod()`.
 
 **Remember one thing:**
-i) We can use static properties or members inside non static blocks or methods without object creation.  
-ii) But we cannot use non static properties or methods inside static blocks or methods without object creation.
+i) We can use static properties or members inside non-static blocks or methods without object creation.
+ii) But we cannot use non-static properties or methods inside static blocks or methods without object creation.
 
 ---
-
-This completes the code and theory as discussed without any changes or additions.