feat: Add detailed documentation on static keyword usage, memory allocation, and behavior in Java

WHAT the doc covers:
- **Definition and purpose of static keyword**:
  - Makes variables, methods, or blocks independent of object instances.
  - Shared across all objects of a class.
  - Example: `static int a = 5;` is accessible by all instances.

- **Where static can be used**:
  - Static variables: single copy shared by all objects.
  - Static blocks: executed once when the class is loaded.
  - Static methods: callable without creating an object; limited to static members.
  - Static nested classes: inner classes that can exist without an outer class instance.

- **Memory allocation**:
  - Class loading process explained:
    1. Compilation creates `.class` file.
    2. JVM loads class with Class Loader System.
    3. Static variables initialized and static blocks executed during class load.
  - Static variables live in class-level memory, not per object, making them object-independent.

- **Static vs instance variables**:
  - Static variables → belong to the class; changes are reflected across all objects.
  - Instance variables → belong to each object; changes affect only the specific instance.
  - Demonstrated with Calc example:
    - Modifying obj1.stA changes it for obj2.
    - Modifying obj1.inB doesn’t affect obj2’s inB.

- **Static vs non-static blocks**:
  - Static block: executes once when class is loaded, before main().
  - Non-static block: executes before constructor, every time a new object is created.
  - Example with Calc and Help classes showing execution order.

- **Static vs non-static methods**:
  - Static methods:
    - Called with class name or object reference.
    - Cannot access non-static members without an object.
    - Useful for utility and helper methods.
  - Non-static methods:
    - Depend on object instance to be called.
    - Can access both static and non-static members.
  - Key rules:
    - Non-static code can freely use static members.
    - Static code cannot access non-static members without an object reference.

WHY this matters:
- Understanding static keyword is essential for:
  - Designing efficient memory usage with shared data.
  - Implementing utility classes (e.g., Math).
  - Handling initialization logic correctly with static blocks.
  - Avoiding confusion between class-level and object-level state.

Short key: java static keyword memory-allocation static-vs-instance methods blocks variables.

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

Author: Someshdiwan

Section16StaticFinal/src/static keyword.txt

@@ -1,33 +1,37 @@
-Below is the generated theory and code exactly as discussed:
+### 1) What is a use static keyword in Java?
 
----
+**Use of static keyword:**
 
-### 1) What is use static keyword in Java?
+When we are using the static keyword with a variable, block, or method, it becomes independent of the object.
 
-**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**  
+
 ```java
 class Calc {
     static int s;
 }
 ```
 
 b) **Before a block**  
+
 ```java
 class Calc {
     static {
@@ -37,13 +41,15 @@ class Calc {
 ```
 
 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)*  
+
 ```java
 class OuterClass {
     int x = 10;
@@ -55,16 +61,16 @@ class OuterClass {
 
 ---
 
-### 3) When memory get allocated
+### 3) When memory gets allocated:
 
 For that we need to know some terms:  
 a) Stack area  
 b) Heap area  
 c) Class loader system  
 
-**Step 1:** When you compile the code you get a `.class` file.  
+**Step 1:** When you compile the code, you get a `.class` file.
 **Step 2:** When you execute (using `java MainClass`), the class is loaded by the Class Loader System.  
-**Step 3:** During class loading, static variables are initialized and static blocks get executed.  
+**Step 3:** During class loading, static variables are initialized, and static blocks get executed.
 **Step 4:** Since static variables get memory in the heap before object creation, they are independent of the object.
 
 ---
@@ -139,20 +145,17 @@ class Help {
     }
 }
 
-/*
 Output:
 Static Block
 Executed before main
 main method
 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()`.
@@ -161,4 +164,4 @@ Hello
 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.
 
----
+---