Question: I was wondering how Java takes the following scenario

```
public static void main(String[] args) throws IndexOutOfBoundsException, CoordinateException, MissionException, SQLException, ParserConfigurationException {
    try {
        doSomething();
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

```

In the above code, I am declaring the main function to throw many different exceptions, but inside the function, I am catching the generic Exception. I am wondering how java takes this internally? I.e., say `doSomething()` throws an IndexOutOfBounds exception, will the e.printStackTrace() get called in the last `catch (Exception e) {...}` block?

I know if an exception not declared in the throws area of the function gets thrown, the try/catch will handle it, but what about exceptions mentioned in the declaration?

Answer: 
The catch block has **greater priority** over the method level throw declarations. If something would pass by that catch block, it would be thrown by the method (but that's not the case since all your mentioned exceptions are indeed inheriting from the `Exception`).

If you need an exception to be handled by the catch block but forwarded further, you would have to rethrow it, e.g.

```
throw e;

```
> 
> say doSomething() throws an IndexOutOfBounds exception, will the
>  e.printStackTrace() get called in the last catch (Exception e) {...}
>  block?
> 
> 
> 

Yes, `e.printStackTrace()` will be called. Because you have caught `Exception`which is broader than (either direct or indirect super class of )`IndexOutOfBoundException` or any of the other exceptions that you have put in throws clause. But if you catch some exceptions which is narrower than `IndexOutOfBoundException` and other exceptions in throws clauses and any of these exceptions is encountered then throws clause will trigger.