为什么在Java中捕获异常，当您可以捕获Throwables？(Why catch Exceptions in Java, when you can catch Throwables?)

 它不是基于可转换为参数类型的类型数量 - 由于隐式转换，是否对一个重载有效的任何值对另一个重载有效。 
 
 例如，有一个从String到Object的隐式转换，但反之亦然，所以String比Object更具体。 
 
 同样地，从B到A有一个隐式的转换，但反之亦然，所以B比A更具体。 
 
 然而，使用A和E ，两者都不比其他的更具体 - 没有从A转换为E ，也不从E转换为A 这就是为什么重载解析失败。 
 
 JLS的相关位实际上是15.12.2.5 ，其中包括这可能会使您更容易理解： 
 
 
 
 非正式的直觉是，如果第一种方法处理的任何调用可以传递给另一种方法而没有编译时错误，则一种方法比另一种方法更具体。 
 
 
 所以如果你有： 
 
void foo(String x)
void foo(Object x)
 
 foo(String)处理的每个调用都可以由foo(Object)处理，但情况并非如此。 （例如，您可以调用foo(new Object()) ，并且无法由foo(String)处理。） 

It's not based on the number of types that are convertible to the parameter type - it's whether any value that's valid for one overload is valid for another, due to implicit conversions.
 
For example, there's an implicit conversion from String to Object, but the reverse isn't true, so String is more specific than Object.
 
Likewise there's an implicit conversion from B to A, but the reverse isn't true, so B is more specific than A.
 
With A and E however, neither is more specific than the other - there no conversion from A to E, and no conversion from E to A. That's why overload resolution fails.
 
The relevant bit of the JLS is actually 15.12.2.5, which includes this that might make it easier for you to understand:
 
 
 
The informal intuition is that one method is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time error. 
 
 
So if you have:
 
void foo(String x)
void foo(Object x)
 
every invocation handled by foo(String) could be handled by foo(Object), but the reverse is not the case. (For example, you could call foo(new Object()) and that couldn't be handled by foo(String).)