Final vs Finally vs finalize()

"final", "finally", and "finalize()" look similar and are a classic source of confusion for Java learners, but they belong to three completely unrelated parts of the language: a keyword that restricts modification, a block that guarantees cleanup code runs, and a deprecated method once tied to garbage collection.

Knowing the difference precisely — not just that "they're different" — is a frequent interview question and also affects real code decisions, especially now that finalize() is deprecated and should not be used in new code.

Why it matters

These three names look related and have nothing to do with each other: a keyword, a block and a deprecated method. Being asked to distinguish them is one of the oldest Java interview questions. The useful part is the last one — understanding why finalize() was abandoned tells you how resources should really be released.

final — a Keyword

final is a modifier applied to variables, methods, or classes to restrict change.

• A final variable can be assigned exactly once; after that its value (or, for a reference, the object it points to) cannot be reassigned.
• A final method cannot be overridden by a subclass.
• A final class cannot be extended/subclassed at all (e.g. String and Integer are final classes).

finally — a Block

finally is a block attached to a try statement (try { ... } finally { ... }, with or without a catch) that is guaranteed to execute after the try block finishes, whether it completed normally, threw an exception, or executed a return statement. It exists specifically for cleanup code — closing files, releasing locks, closing database connections — that must run regardless of what happened in the try block.

finalize() — a Deprecated Method

finalize() is a protected method defined on Object that the garbage collector historically called on an object right before reclaiming its memory, giving it one last chance to release resources. In practice it was unreliable: there was no guarantee about when, or even if, it would run before the JVM exited, and it made garbage collection slower and harder to reason about. Object.finalize() has been deprecated since Java 9 and was removed from later JDK versions entirely. The modern replacement for deterministic cleanup is try-with-resources together with the AutoCloseable interface, which closes a resource predictably at the end of the try block instead of at some unpredictable future garbage-collection cycle.

Examples

final class ImmutablePoint {           // final class: cannot be extended
    final int x;                       // final field: assigned once, in the constructor
    final int y;

    ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    final String describe() {          // final method: cannot be overridden
        return "(" + x + ", " + y + ")";
    }
}

public class FinalDemo {
    public static void main(String[] args) {
        ImmutablePoint p = new ImmutablePoint(3, 4);
        System.out.println(p.describe());
    }
}

(3, 4)

public class FinallyVsCleanupDemo {

    static int divide(int a, int b) {
        try {
            return a / b;
        } finally {
            System.out.println("finally block runs even though we are returning");
        }
    }

    public static void main(String[] args) {
        try {
            // divide() runs, and its finally prints, before println prints the result
            System.out.println("Result: " + divide(10, 2));
            System.out.println("Result: " + divide(10, 0));
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        // Modern cleanup pattern: AutoCloseable + try-with-resources (not finalize())
        try (java.io.StringWriter writer = new java.io.StringWriter()) {
            writer.write("hello");
            System.out.println("Wrote: " + writer.toString());
        } catch (java.io.IOException e) {
            System.out.println("IO error: " + e.getMessage());
        }
        // writer.close() is called automatically here, deterministically
    }
}

finally block runs even though we are returning
Result: 5
finally block runs even though we are returning
Caught: / by zero
Wrote: hello

Exercise

Complete Connection so it can be used in a try-with-resources statement. Its close() method should print closed, and it must be called automatically.

Expected output: open, work, closed

// TODO: make Connection implement AutoCloseable and add close()
class Connection {
    Connection() {
        System.out.println("open");
    }

    void work() {
        System.out.println("work");
    }
}

public class ResourceDemo {
    public static void main(String[] args) {
        try (Connection connection = new Connection()) {
            connection.work();
        }
    }
}

class Connection implements AutoCloseable {
    Connection() {
        System.out.println("open");
    }

    void work() {
        System.out.println("work");
    }

    @Override
    public void close() {
        System.out.println("closed");
    }
}

public class ResourceDemo {
    public static void main(String[] args) {
        try (Connection connection = new Connection()) {
            connection.work();
        }
    }
}

Quick quiz

Interview questions