What is try .. finally used for without the catch clause?

Contracts are a common concept in the design and analysis of the correctness of algorithms. The concept is that the functions, methods or other units of our programs must have:

• Preconditions: Conditions that callers must provide in advance for the method to produce correct results;
• Postconditions: Conditions that (given the preconditions) the method promises will occur when it returns;
• Invariants: Conditions that the method promises not to affect—will be true or false on return if and only if they were true on entry.

In this framework, the try { ... } finally { ... }is a useful construct so that our code can guarantee postconditions even when exceptions occur within the del block try { ... }or in any method called within this block. Since the commands inside the block finally { ... }are always going to be executed, exception or not, it is common to put code there that guarantees postconditions.

The examples of "cleaning" that others have given fall within this framework. The idea is that in these examples:

1. A resource such as a file or a connection to a database is used;
2. There is a postcondition that forces the example code to guarantee that the resource will be closed no matter what happens in its use.

This was the most common use of finallyin older versions of Java. In Java 7 a new construct, called "try with resources," was introduced that supplants the try { ... } finally { ... }in its most common uses:

try (OutputStream out = ...) {
    // usar el OutputStream `out`
} // postcondición: `out` ha sido cerrado

Another kind of example is with the synchronization tools between threads ("threads"). In the package java.util.concurrent.locksthere are several kinds of locks ("locks") that are normally used with try {...} finally {...}:

Lock l = ...;
l.lock();
try {
    // Entre los hilos que comparten la cerradura `l`, sólo uno
    // puede entrar en este bloque a la vez.
} finally {
    l.unlock();
}  // postcondición: la cerradura está abierta

But it is worth emphasizing again the concept of postconditions. After all, the try { ... } finally { ... }is not specifically a "cleanup" mechanism but a general tool to facilitate the composition of correct programs. So it has other uses, even if they are much less common than these two.

Other examples can be added. A frequent cause of programming errors is the early exit ("early return") of a function or method. Typical cases are something like this:

public LoQueSea miMétodo(Desto algo, Coso queSéYo) {
    // muchas lineas...

    if (noSéQué()) {
        return new LoQueSea(algo);  // salida temprana
    } 

    // muchas más lineas...

    cosaQueSiempreTieneQuePasar(queSéYo);
    return new LoQueSea(algo.con(queSéYo));
}

Assuming that we always need to call the method cosaQueSiempreTieneQuePasar(), this example has a bug: when it noSéQué()returns with truewe exit early and forget to call cosaQueSiempreTieneQuePasar(). A solution in many cases is the following:

public LoQueSea miMétodo(Desto algo, Coso queSéYo) {
    try {
        // muchas lineas...

        if (noSéQué()) {
            return new LoQueSea(algo);  // salida temprana
        } 

        // muchas más lineas...
        return new LoQueSea(algo.con(queSéYo));
    } finally {
        // Este bloque se ejecuta siempre, aun si hay 
        // salida temprana.
        cosaQueSiempreTieneQuePasar(queSéYo);
    }
}

And here it should be noted that, although many answers have mentioned exceptions as the reason for the try {...} finally {...}, this example shows that we can run into problems even if there are no exceptions. Other examples are possible with breakand continuein repetition structures like for (...) {...}.

Or rather, the exceptions, the returnearly, the breakand the continuehave something in common—early exit of a block of code—and the finallyis a common solution to the problems that all of these cause.

Apparently it's not such a bad practice since the finally will always run can be used for cleaning. I found a couple of examples on the net:

Example 1

public void yourMethod() throws YourException {
    try {
        db.store(mydata);
    } finally {
        db.cleanup();
    }
} 

Example 2

OutputStream os = null;
OutputStreamWriter wos = null;
try { 
   os = new FileOutputStream(...);
   wos = new OutputStreamWriter(os);
   // ......

   wos.flush();
   os.flush();
finally {
   IOUtils.closeQuietly(wos);
   IOUtils.closeQuietly(os);
}

Here a user says that in the following example catchhe would not know what to do with the error so it would be better to add a cleanup routine.

InputStream in = null;
try {
    in = new FileInputStream("file.txt");
    // Hacer algo que lance una excepción
} finally {
    if (in != null) {
         try {
             in.close();
         } catch (IOException e) {
         // Nothing we can do.
         }
    }
}

The block catchis only used to catch any exception that appears during the execution of the code. Since there is no block catch, the exception will be thrown and handled by the client of the method where this block of code is located. If there is no handling of this exception, then the exception will jump to the highest level it can reach. If the highest level is the public static void main(String[] args)application method and it is not handled there, then the application will show the exception that has been thrown and "terminate".

It should be noted that the block finallyis always executed, whether or not the exception was thrown up to the highest level of the application. There are cases where it doesn't run finallybut they are external to this answer. you can see them here

Use try-finallywhen your code doesn't need to handle the exception because another level already exists where it will be handled. For example, in a web application where you have some X component that decorates the components that execute the requests and X already has a way of handling exceptions by default, which will automatically log them and show a "nice" message to the user ( I don't know which error message is actually pretty). An example of this example (forgive the redundancy) is the case of Spring MVC where you can use @ControllerAdviceto handle exceptions at a general level. In this way, if your code throws an exception, it will not be handled by the code itself, but by the class decorated with this annotation.

It is not a bad practice, it is a matter of order.

As other people already mentioned, trywith finallyis used to clean up in case an exception occurs, without catching that exception.

As of Java 7 you have try with resources , there can already be even blocks that only include try:

try (OutputStream s = getOutputStream()) {
    //usar s
}

The finallyis left over because the stream is going to close ending the block.

It could be used in processes that, if they fail, do not need to be informed or alert the user. but it is a bad practice, at least you should record an exception log in the catch

The complete clause is: Try, Catch and Finally. It is possible that they did not use the error catch block because it was not necessary to make any kind of notification... However, you should add it to, in the future, better identify why and where the problem is occurring.

• To close resources (eg open files) without interrupting the flow of throwing exceptions when one occurs.
• To put in that block a code that we always want to be executed, regardless of whether exceptions are thrown or not, for example:System.out.println("Salgo de la funcion Clase1.pepito()");