Suppressed Exception

[Andrzej Zahorski]

Hi, I am reading a tutorial from webpage about supressed  exceptions and have question about correctness of code:

 public static void memberFunction() throws Exception
    {
        Throwable th = null;
        DirtyResource resource= new DirtyResource();
        try
        {
            resource.accessResource();
        }
        catch(Exception e)
        {
            th = e;
        }
        finally
        {
            try
            {
                resource.close();
            }
            catch(Exception e)
            {
                if(th != null)
                {
                    e.addSuppressed(th); //Add to primary exception
                    throw e;
                }
            }
        }
    }
    /**
     * Executable function demonstrating suppressed exceptions.
     */
    @SuppressWarnings("Duplicates")

    public static void main(String[] arguments) throws Exception
    {
        try
        {
            memberFunction();
        }
        catch(Exception ex)
        {
            err.println("Exception encountered: " + ex.toString());
            final Throwable[] suppressedExceptions = ex.getSuppressed();
            final int numSuppressed = suppressedExceptions.length;
            if (numSuppressed > 0)
            {
                err.println("tThere are " + numSuppressed + " suppressed exceptions:");
                for (final Throwable exception : suppressedExceptions)
                {
                    err.println("tt" + exception.toString());
                }
            }
        }
    }
}

Shouldn't last catch be after `if ` statement? I I can have access to resource without exception, but closing it can raise one, so

Throwable th

can be null in this catch. Hence I think this example is incorrect.

[Rob Spoor]

That's a horrible example. If the finally block does not cause an exception, the original exception is never thrown. The following would be a better version:

Exception original = null;
DirtyResource resource = new DirtyResource();
try {
    resource.accessResource();
} catch (Exception e) {
    original = e;
} finally {
    try {
        resource.close();
    } catch (Exception e) {
        if (original == null) {
            throw e;
        } else {
            original.addSuppressed(e);
            throw original;
        }
    }
    if (original != null) {
        throw original;
    }
}

This not only throws an exception whenever anything went wrong, it also throws the correct exception - the one thrown from the main body, not the one thrown from the cleanup.

Of course, the following is (nearly) identical to the above but much, much cleaner:

try (DirtyResource resource = new DirtyResource()) {
    resource.accessResource();
}

The only thing that's different is the scope of the resource variable.

[Andrzej Zahorski]

Thank's I'm adding this website to my blacklist. BTW, do you know any good resource for Core stuff?
I searched many websites and to be honest people do tons of mistakes in them. I read:
* Official tutorials - often lacking in examples
* Jenkov tutorials - webpage - bad practices in code, some of theads examples didn't work.
* Baeldung webpage - good but there's no order in it

The best page I've seen is Journaldev: webpage

Books:
* Thinking In Java - extensive private libraries and Java 7
* Core Java by Cay Horstmann - scope of topics is often wrongly placed - for example in String API guy writes multiple pages about System.out.format - this is not crucial knowledge in programming.

[Campbell Ritchie]

Andrzej Zahorski wrote:. . . * Core Java by Cay Horstmann - scope of topics is often wrongly placed - for example in String API guy writes multiple pages about System.out.format - this is not crucial knowledge in programming.

Disagree. Core Java is not a beginner's book; you needn't expect the chapters to be in the order you would teach a beginner. Also, System.out.format and its brother, System.out.printf(), are used all the time. Once you start programming anything using the terminal/command line, you will use System.out.format()/printf() on every page, and you will need to know about the many combinations of % tags. So I think the coverage you are complaining about is probably correct.