Maybe it's lame question - java help on CodeGym

public class Solution {
    public static void main(String[] args) {
        DBConnectionManager dbConnectionManager = new DBConnectionManager();
        try (FakeConnection fakeConnection = dbConnectionManager.getFakeConnection()) {
            System.out.println("Entering body of try block.");
            fakeConnection.usefulOperation();
            fakeConnection.unsupportedOperation();
        } catch (Exception e) {
        }
    }

public class FakeConnection implements AutoCloseable {

    public FakeConnection() {
        System.out.println("Establishing database connection...");
    }

    public void unsupportedOperation() {
        System.out.println("Operation is not supported yet!");
        throw new RuntimeException("UnsupportedOperation!");
    }

    public void usefulOperation() {
        System.out.println("Executing useful operation.");
    }

    @Override
    public void close() throws Exception {
        System.out.println("Closing database connection...");
    }
}

Output is without RuntimeException: Establishing database connection... Entering body of try block. Executing useful operation. Operation is not supported yet! Closing database connection... We have something like this, and I'm curious, because I though that in unsupportedOperation() we trow new RuntimeException() , but it is not what happened. Why? I don't know how understand teachers acapit from conditions: "Note that the resources were released automatically, despite the fact that an exception was thrown by the unsupportedOperation method. Requirements:"

} catch (RuntimeException re) { System.out.println("Wondering about a RuntimeException " + re.getMessage()); } catch (Exception e) { System.out.println("There was an error closing the FakeConnection"); }

Comments (3)

Popular
New
Old

You must be signed in to leave a comment

Thomas

Level 41 , Bayreuth, Germany

4 March 2023, 20:26

solution

A RuntimeException is a descendant of Exception. Difference is, that you have to handle all Exceptions whereas you may handle RuntimeExceptions. In that task you opted to handle all Exceptions in the Solution class (you catch all Exceptions) but you do nothing at all inside the catch block. You don't print the stacktrace,

e.printStackTrace();

you don't throw up the exception.

throw new RuntimeException(e);

or anything else like:

if (e instanceof RuntimeException)
    System.out.println("Wondering about a RuntimeException " + e.getMessage());
else
    System.out.println("There was an error closing the FakeConnection");

That's why you see nothing. The if-else you usually won't do and instead you cascade catch blocks

Try these things and you'll see how that all's working A regular exception will only be thrown by the close method of FakeConnection. Even if you provoke that you'll never see it as the RuntimeException occurs before. You can either remove the RE or you throw an Exception in main before the RE (unsupportedOperation). You'd need to fake it like:

if (true)
    throw new Exception();

The main point is, that even if that invisible RuntimeException is thrown, the resource is getting closed. That's why you should use try-with-resources where possible, even if it is just to close resources and not to handle exceptions.

matemate123

Level 50 , Kraków, Poland

4 March 2023, 20:47

Now I see, it's like I throw new RuntimeException in unsupportedOperation() but it's not happen because I catch it outer scope (in main), but not print message.

4 March 2023, 21:05

Yes, IntelliJ even warns you about that. Mouseover the yellow catch and you get a 'Empty catch block' warning. Or open the problems tab (alt-6). To disable the warning you'd need to change the Exception reference variable to some word beginning with ignore (eg. ignore or ignored) (you can disable that altogether in the settings, editor->inspections->java->error handling)