AY 19/20 Sem2 Qn4 : Exceptions Ordering.

[Herrekt]

Summary

I know that we should focus on the more specific exceptions to the least specific ones, but if they branch off from the same parent exception, can we clear one whole child exception first before starting on the next?

Description

For example, if we were to catch NoPermissionException, then catch WriteException, before catching ElementNotFoundException and Read Exception, will it be problematic/wrong in this case?

Screenshots (if any):

[brendancjz]

Hi, I believe either way is fine. The more common approach will be to the finish catching the child exception of a branch. As long as you are always catching the next most specific exception, you're good.

[raihanyusri]

Either way is fine. If the exceptions have a parent-child relationship, then the catch blocks must be sorted by the most specific exceptions first, followed by the most general ones within the group itself

[gableejh]

both works or you can use | to catch both, refer to slide 10 of lecture 6

[liongthryan]

I think your method works fine! If you're writing the code in an IDE, most IDEs flag unreachable code blocks (ie. you tried to catch a more general exception before catching the specific exception). Since prof said we can write our answers for finals using any IDEs (iirc), it might not be a bad strategy to just rely on those!

[deniselam10]

I think its fine! As long as the later exception is not more specific than the one caught previously, your code should work.

[yowyuxuan]

I did it in a similar way as well! so long it is bottom up! :)

[MatthiasTanWeiSheng]

i think both is fine. As long as you are catching the more specific exceptions first.

[yx0555]

I did it the same way as you too, should work since the more specific exceptions are called first!

[criyu95]

Both ways are fine, as long as the more specific exceptions are caught first

[amaslua]

It should work, i did it the same way as u! as long as more specific to less specific

[jeremycte]

Hi @Herrekt , you can view more in-depth based on my explaination here #307 but basically either way is fine. The primary goal is to catch the more specific exceptions/ child exceptions before catching the general exceptions/parent exceptions last. 😃

[linminsaw]

In general, as long as you catch the exceptions from the most specific to the most general, it will work well :)

[YuanZhengyz]

Yup as long as you don't accidentally check for a more general exception first it will be fine.

[andreathr]

I think as long as you catch the most specific exception which is the NoPermissionException its fine!

[Jjjetplane]

As long as you are catching them from the most specific to the most general it will work!

[gwajoon]

It will work as long as you catch them in order of specificity, starting from the most specific one!

[dannytayjy]

try { 
    accessDatabase();
} catch (NoPermissionException e1) {
    System.out.print("NoPermissionException");
} catch (ElementNotFoundException e2) { 
    System.out.print("ElementNotFoundException");
} catch (WriteException e3) {
    System.out.print("WriteException");
} catch (ReadException e4) {
    System.out.print("ReadException");
} catch (TableException e5) {
    System.out.print("TableException");
} catch (DatabaseException e6) {
    System.out.print("DatabaseException");
}

[ErMingYong]

rule of thumb is to just catch the more specific errors than the more general errors. Arrangement not be a problem unless you catch a more general error before a more specific error instead

[W-ShiHan]

I think that both your answers work.

Personally I draw out my workings in a tree,
then you can either

1. Check exceptions in the order of their distance away from the root (furthest away first)
2. Start from any "leaf" of the tree and check for exceptions backwards, and repeat until all exceptions have been checked.
   (sorry for my poor handwriting)
   

[JWulaXia]

idea is go from the most specific exception, if two exception are at the same level, the the order does not matter. this can ensure all exceptions are caught and are caught in the most specific one