C++ Memory Management vs. Java Memory Management
📌 In C++, dynamic memory is created using the `new` keyword and must be manually released using the `delete` keyword to prevent memory leaks.
🛑 In C++, if dynamic memory is allocated but the pointer referencing it goes out of scope (e.g., when a function ends), the memory remains allocated but inaccessible, causing a memory leak.
☕ Java does not have a `delete` keyword; object memory is always allocated dynamically using `new`.
💻 Java manages memory release automatically through a mechanism called Garbage Collection (GC).

Java Garbage Collection (GC)
🎯 Garbage is defined as any object block that is not referenced by any live reference variable; these are "garbage blocks" eligible for release.
🗑️ The process of collecting and releasing the memory of these garbage blocks is known as Garbage Collection.
⚙️ Garbage Collection is handled by a dedicated thread within the JVM, alongside the Main thread and the Thread Scheduler thread.

The Finalization Process
📞 Before a garbage block is destroyed by the GC, it calls a special method within that object called `finalize()`.
🔄 The `finalize()` method is conceptually similar to the destructor in C++, executing cleanup tasks just before memory is reclaimed.
⚠️ While you can *request* the GC to run using methods like `System.gc()`, it is not guaranteed to execute immediately or at all, as the JVM decides when to run the collector.

Key Points & Insights
➡️ Manual Memory Management (C++) requires programmers to explicitly use `delete` to avoid memory leaks caused by inaccessible dynamic allocations.
➡️ Automatic Memory Management (Java) ensures that objects without any live references are automatically identified and reclaimed by the Garbage Collector thread.
➡️ If an object needs last-minute cleanup before memory is freed, developers can implement the `finalize()` method, which is executed by the GC just before destruction.

📸 Video summarized with SummaryTube.com on Dec 30, 2025, 13:50 UTC