Introduction

Yes, using try with finally and no catch is valid Java and often the right choice. The purpose of that structure is not to handle the exception locally. The purpose is to guarantee cleanup while still allowing the exception to propagate to the caller.

What finally Guarantees

A finally block runs whether the try block completes normally or throws an exception. That makes it useful for cleanup operations such as closing files, releasing locks, or restoring temporary state.

1public static void readFile() throws Exception {
2    java.io.BufferedReader reader = new java.io.BufferedReader(
3        new java.io.FileReader("data.txt")
4    );
5
6    try {
7        System.out.println(reader.readLine());
8    } finally {
9        reader.close();
10    }
11}

If reading the file fails, the exception still propagates. But reader.close() is still attempted first.

Why You Might Skip catch

Sometimes the current method is not the right place to recover from an error. It may have no useful fallback and no meaningful way to continue. In that case, catching the exception just to rethrow it or log it badly adds noise.

A try-finally block keeps the important guarantee:

• cleanup happens here
• error handling can happen at a higher level

That separation is often cleaner than forcing every method to decide how to recover from exceptions it cannot really handle.

Resource Management Example

Before try-with-resources, try-finally was the standard way to close resources safely.

1java.sql.Connection connection = dataSource.getConnection();
2try {
3    // Use the connection
4} finally {
5    connection.close();
6}

This is still conceptually useful, even though modern Java usually prefers try-with-resources for AutoCloseable types.

Prefer try-with-resources When Available

For files, streams, JDBC statements, and other AutoCloseable resources, modern Java code is often better written like this:

1try (java.io.BufferedReader reader = new java.io.BufferedReader(
2        new java.io.FileReader("data.txt"))) {
3    System.out.println(reader.readLine());
4}

This is usually clearer and less error-prone than manually writing finally cleanup. Still, understanding try-finally matters because not every cleanup task is an AutoCloseable, and older codebases use the pattern heavily.

Be Careful Inside finally

The finally block should avoid throwing a new exception that hides the original one. Cleanup code should be simple and deliberate. If the cleanup itself can fail, decide whether that secondary failure should be logged, wrapped, or handled in some other controlled way.

The point of finally is reliability, not complication.

A Good Design Signal

A method that uses try-finally without catch is often expressing something healthy about the design: this layer owns cleanup, but not recovery policy. That separation is useful in service code, transaction code, and low-level utilities where local cleanup is mandatory but the caller still needs to decide how the failure should be surfaced or translated.

Older Code and Modern Code

You will still see try-finally heavily in older Java codebases because it predates try-with-resources. Reading it correctly is important during maintenance: the pattern is not obsolete in principle, but many resource-management cases can be simplified today by refactoring them into try-with-resources while preserving the same cleanup guarantee.

Common Pitfalls

• Catching an exception only to rethrow it immediately when try-finally would be clearer.
• Writing cleanup in finally that can mask the original failure.
• Using try-finally for AutoCloseable resources when try-with-resources would be simpler.
• Assuming finally is for error recovery rather than guaranteed cleanup.
• Putting too much business logic in finally instead of keeping it focused on cleanup or restoration.

Summary

• 'try-finally without catch is valid and useful in Java.'
• It is appropriate when cleanup must happen locally but recovery should happen elsewhere.
• 'finally guarantees cleanup attempts even when exceptions are thrown.'
• Prefer try-with-resources for modern AutoCloseable resource handling.
• Keep finally blocks small so they do not obscure or replace the original failure.