Home

Learning Hub

Articles

Understanding Final, Finally, Finalize in Java: A Detailed Comparison

The three words: final, finally, finalize in Java: sound similar, but each has a very different purpose. Most developers mix them up at first glance, but each of them covers a unique part of Java programming:

• final: It locks things down. When we use final, it means that whatever we are working with cannot be changed.
• finally: This one guarantees the execution of specific code regardless of what may happen. It’s just a promise that something is always going to be executed.
• finalize(): This method is rather more of a goodbye call. It is invoked just before an object is cleaned up by Java’s garbage collector.

Let’s take a deep dive into each one, starting with the final keyword.

Detailed Explanation of the final Keyword: Restricting Classes, Methods, and Variables

When we declare something as final, we are saying that something can’t change. And that is so, irrespective of whether it is a class, a method, or a variable

Final Classes

A final class cannot be extended. Once we lock it down with final, nobody is going to come in and make a subclass.

This comes in handy when we do not want anyone to mess with the core structure.

This prevents developers from making a subclass that could modify the way things work within the class.

Also Read: Exception Handling in Java

Example:

Output:

Final Methods

A final method essentially means that nobody can override it in any subclass.

This locks up the behavior of the method and guarantees that its behavior won’t change no matter how many layers of inheritance exist.

By using final keyword on methods, we ensure that critical methods behave exactly as intended.

Example:

Output:

Final Variables

With final variables, the story is simple—once they’re set, we can’t change them.

Let’s say we have a variable for a student’s roll number. Once it’s assigned, it stays the same.

Example:

Output:

The Functionality of the finally Block in Java’s Exception Handling

This is all about the fact that something should be done regardless of whatever.

If we are throwing exceptions in Java, then we mostly use try and catch blocks. However, there is always that one question- what if we want to run some piece of code, no matter whether an exception occurs or not?

That’s where the finally block comes into play.

The code within the finally block is always executed, with or without an error.

Also Read: Difference Between Throw and Throws in Java

Why Use the Finally Block?

Consider you opened a file, and worked with it, but now something got wrong in the middle.

You would want the file closed, even if there was an error.

That’s what finally is for.

It ensures that there are cleanup activities – which your application probably would like to do, such as closing resources – executed even in the presence of an error, which disrupts the usual execution of the program.

Example:

Output:

Notice that in both cases, the finally block runs and closes the scanner, preventing resource leaks.

When Is finally Most Useful?

The finally block is a lifesaver when it comes to cleaning up resources:

• Closing files
• Closing database connections
• Releasing memory or cleaning up objects

Without finally, we’d have to manually handle resource cleanup, which can easily get missed, especially in large applications.

Also Read:  Types of Exceptions in Java

Purpose and Limitations of finalize() Method in Java Object Life Cycle

What happens when the object in Java is no longer in use?

At some point, it must be cleaned up to free its memory for other processes.

This is where garbage collection comes in and with it the finalize() method.

While it gives us a chance to clean things up before the object is destroyed, there are some limitations we need to be aware of.

What Does finalize() Actually Do?

The finalize() method is called by the Garbage Collector right before an object is removed from memory.

It will let us do things like close files or release network connections still open.

Example:

Output:

Why finalize() Isn’t Reliable

The finalize() method looks like a convenient way to clean up objects.

But the timing isn’t predictable.

The Garbage Collector runs its own schedule. It may never call finalize() for an object soon after the object becomes eligible for collection.

Even worse, finalize() might never even get run at all. If the program terminates before garbage collection happens, then the method will never be invoked.

This unpredictability makes finalize() hazardous when you need to do resource cleanup.

A More Suitable Solution: Try-with-Resources

So, if finalize() isn’t really the solution for cleanup then what can we use?

There’s a better, more reliable way of resource cleanup in Java – try-with-resources. It automatically closes resources like files and streams once the try block is done.

Here’s an example of how it works:

Example:

Output:

In this case, the FileWriter is automatically closed when the block finishes. We don’t have to rely on the unpredictable finalize() method.

Now that we’ve covered all three terms, let’s look at the key differences between final, finally, finalize in Java.

Here’s a simple table to break it down:

Best Practices for Developers When Using final, finally, and finalize in Java

Confusing final With Immutability

It is very tempting to believe that final makes the object immutable but nope it doesn’t.

It just prevents us from reassigning the variable. If the object itself has some mutable properties, those can still change.

Example:

In this case, we can still change the contents of sb, but we cannot reassign it.

Forgetting to Close Resources in the finally Block

Most developers forget to use finally for closing resources like files and database connections.

If left open, there will be major problems such as memory leaks or file locks. Make it a habit to close everything inside finally block or rather use try-with-resources.

Relying on finalize() for Critical Cleanup

We are not supposed to use finalize() for important cleanup, such as database connection. We do not know exactly when it actually runs; so, it could miss the cleanup call.

Always prefer try-with-resources or explicit close() calls for non-critical cleanup.

Overriding final Methods

Trying to override a method if it’s declared as final will give a compilation error.

This happens when developers are unaware of the fact that final locks down method behavior. Verify if a method is final before you try to override it.

Misusing finally with Return Statements

Often people think that the finally block gets skipped if a return statement is hit in the try or catch blocks, but that’s not true. The finally block will always run, even after a return statement.

Example:

Output:

Real-World Use of  final, finally, finalize in Java Programs: Unique Code Examples

You’ve probably wondered how final, finally, finalize in Java can be used in actual programs. The best way to understand them is by diving into some real-world code examples.

Also Read: Java Interview Questions and Answers

Using final for Constants and Secure Methods

When we use final in real programs, it’s often to create constants or secure methods that can’t be changed by accident.

Take this final variable example:

Output:

For methods, it’s a similar story. Once a method is marked final, it can’t be overridden.

Using finally for Resource Cleanup

This is where we make sure important things—like closing files or database connections—always happen. This ensures we don’t leave any open resources hanging around.

Here’s an example using a file read operation:

When to Use finalize() in Object Cleanup

While finalize() isn’t widely used anymore, there are still times when you might see it, especially in older codebases.

Here’s an example where finalize() is used to clean up before an object is garbage collected:

Output:

The Role of finally in Ensuring Resource Cleanup and How It Helps Avoid Leaks

The finally block will indeed execute whether the exception occurs or not. It ensures that resources are being closed, thus preventing potential memory leaks or file locks.

Imagine every time you open a resource, often it will not close correctly especially if something goes wrong with your code.

This is why we rely on finally to clean up the mess.

A Common Pitfall: Forgetting to Close Resources

Imagine that you are working with a database and that you forgot to close the connection after using it. That can cause resource exhaustion, slowing down your application or even crashing it.

By placing your clean-up code in the finally block, you guarantee it will run no matter what else happens.

Conclusion

Understanding final, finally, and finalize in Java is important for writing good programs. All serve a different purpose: final forbids classes, methods, or variables from being modified; finally ensures critical code always runs – useful if you have cleanup code that needs to execute; and finalize() cleans up objects on garbage collection, although its use is now considered generally unreliable.

The code goes stable if it’s implemented with final for security, finally for resource management, and avoiding finalize() for the use of try-with-resources. Acknowledging these differences eliminates many common errors in code and generally improves its quality, making it easier to control and less likely to throw issues.

If you want to enhance your skills and develop expertise in Java as well as other technologies, then the Certificate Program in Full Stack Development with Specialization for Web and Mobile at Hero Vired can be the perfect course for you. It helps you to be equipped with the most advanced tools and techniques needed for successful web and mobile development that would boost your career as a full-stack developer.