What is the difference between final, finally, and finalize?

Question

Accepted Answer

**final** — a keyword that prevents modification. **finally** — a block that always executes after try/catch. **finalize()** — a deprecated method called before garbage collection. Analogy: **final** is like a locked door — once set, you can't change it. **finally** is like the cleanup crew that always comes in after an event, no matter what happened. **finalize()** is like a demolition crew that used to come before tearing down a building, but is now obsolete. **final keyword (3 uses):** 1. **final variable** — cannot be reassigned: ```java final int MAX_SIZE = 100; MAX_SIZE = 200; // COMPILE ERROR: cannot assign a value final String name = "Alice"; name = "Bob"; // COMPILE ERROR // For objects, "final" means the reference can't change, // but the object's fields CAN change: final List list = new ArrayList<>(); list.add("item"); // OK — modifying the object list = new ArrayList<>(); // COMPILE ERROR — can't reassign reference ``` 2. **final method** — cannot be overridden by subclasses: ```java class Parent { final void importantMethod() { System.out.println("This cannot be overridden"); } } class Child extends Parent { void importantMethod() { } // COMPILE ERROR: cannot override final method } ``` 3. **final class** — cannot be extended (no subclasses): ```java final class ImmutablePoint { private final int x; private final int y; public ImmutablePoint(int x, int y) { this.x = x; this.y = y; } // No setters — truly immutable } class SubPoint extends ImmutablePoint { } // COMPILE ERROR: cannot extend final class ``` **finally block:** - Executes **always** — whether the try block succeeds, throws an exception, or the method returns. - Used for **cleanup**: closing files, releasing connections, unlocking resources. - Runs even if `return` is called in try/catch (it executes before the return). - Multiple finally blocks are NOT allowed. ```java FileInputStream fis = null; try { fis = new FileInputStream("data.txt"); // read data... } catch (FileNotFoundException e) { System.err.println("File not found"); } catch (IOException e) { System.err.println("Read error"); } finally { // Always runs — close the resource if (fis != null) { try { fis.close(); } catch (IOException e) { System.err.println("Error closing stream"); } } System.out.println("Cleanup complete"); } // Better: use try-with-resources (Java 7+) try (FileInputStream fis2 = new FileInputStream("data.txt")) { // read data... } catch (IOException e) { System.err.println("Error: " + e.getMessage()); } // fis2 is automatically closed here — no finally needed ``` **finalize() method (DEPRECATED since Java 9):** - Called by the garbage collector before reclaiming the object's memory. - `protected void finalize() throws Throwable { }` — inherited from Object. - **Never use it** — unreliable, unpredictable timing, performance issues. - Use `AutoCloseable` + try-with-resources instead. ```java // OLD, BAD approach: class OldResource { @Override protected void finalize() throws Throwable { try { // cleanup resources System.out.println("Finalize called"); } finally { super.finalize(); } } } // MODERN approach: class ModernResource implements AutoCloseable { @Override public void close() { System.out.println("Resource closed deterministically"); } } // Usage: try (ModernResource resource = new ModernResource()) { // Use resource } // close() called automatically and immediately ``` **Why finalize() is dangerous:** - You don't know WHEN (or if) it will be called. - It can delay garbage collection and cause memory leaks. - Exceptions in finalize are silently swallowed. - It can resurrect objects (accidentally keep them alive). **Summary:** final = immutable/constant. finally = always runs for cleanup. finalize() = deprecated, avoid entirely.

Java: What is the difference between final, finally, and finalize?