Flow of Java Program 3 Level

# Flow of Java Program — 3 Levels

## 🟢 Level 1 — Beginner

Think of a Java program as a simple journey:

```text
Java Source Code
      ↓
   Compile
      ↓
   Bytecode
      ↓
     JVM
      ↓
    Output
```

### Example

You write:

```java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello Java");
    }
}
```

Save it as:

```text
Hello.java
```

Compile:

```text
javac Hello.java
```

This produces:

```text
Hello.class
```

Then run:

```text
java Hello
```

The JVM executes the bytecode and produces:

```text
Hello Java
```

### ⭐ Remember

> **`.java → javac → .class → JVM → Output`**

---

# 🟡 Level 2 — Intermediate

Now add the important internal steps.

```text
       Hello.java
           ↓
      Java Compiler
         javac
           ↓
       Bytecode
       Hello.class
           ↓
      Class Loader
           ↓
     Verification
           ↓
       Linking
           ↓
    Initialization
           ↓
       JVM Execution
           ↓
    Interpreter / JIT
           ↓
      CPU / OS
           ↓
         Output
```

### What happens at each stage?

**1. Source Code**
You write Java instructions in `.java`.

**2. Compilation**
`javac` checks the code and converts it into bytecode.

**3. Bytecode**
Stored in `.class` files and designed for the JVM.

**4. Class Loading**
The JVM loads required classes.

**5. Verification**
The JVM checks that the bytecode is valid.

**6. Linking**
The JVM prepares the class for execution.

**7. Initialization**
Static initialization is performed when required.

**8. Execution**
The JVM executes the program.

---

# 🔴 Level 3 — Advanced

At the JVM level, the flow becomes:

```text
Java Source
    │
    ▼
   javac
    │
    ▼
JVM Bytecode
    │
    ▼
Class Loading
    │
    ├── Loading
    │
    └── Linking
          ├── Verification
          ├── Preparation
          └── Resolution
    │
    ▼
Class Initialization
    │
    ▼
JVM Runtime
    │
    ├── Heap
    ├── Java Stacks
    ├── PC Registers
    └── Other runtime areas
    │
    ▼
Bytecode Execution
    │
    ├── Interpreter
    │
    └── JIT Compiler
             ↓
       Native Machine Code
             ↓
            CPU
             ↓
          Output
```

### Where does memory fit?

During execution, the JVM manages runtime memory.

```text
JVM
├── Heap
│    └── Objects
│
├── Java Stack
│    └── Method frames
│
└── Other runtime areas
```

For example:

```java
Student s = new Student();
```

Conceptually:

```text
Stack                  Heap
─────                  ────
s ──────────────────→ Student object
```

The **garbage collector** can later reclaim heap memory occupied by objects that are no longer reachable.

---

# 🔥 The 3-Level Revision

| Level           | Flow                                                                                                                 |
| --------------- | -------------------------------------------------------------------------------------------------------------------- |
| 🟢 Beginner     | `.java → javac → .class → JVM → Output`                                                                              |
| 🟡 Intermediate | `Source → Compile → Bytecode → Load → Verify → Link → Initialize → Execute`                                          |
| 🔴 Advanced     | `Source → Bytecode → Class Loading → Linking → Initialization → Runtime Areas → Interpreter/JIT → Native Code → CPU` |

### 🧠 Ultimate memory trick

**W → C → B → L → V → I → E → O**

**Write → Compile → Bytecode → Load → Verify/Link → Initialize → Execute → Output**

> **Java source code becomes bytecode; the JVM loads, verifies, links, initializes, and executes that bytecode, using interpretation and JIT compilation as appropriate.**