This isn't a comparison that can be made.  The two language constructs
do different things.  You should use try and catch when you want to
handle an error.  You should use throws when you want to declare that
someone else needs to handle an error.

It is a matter of who knows best what to do when something goes wrong.
IF you can fix the problem, e.g. restart the connection, then you
should handle the exception with a catch.  If you can't, generally you
should pass the exception on up.  Sometimes you do both, catch, do
something to handle or report the exception, then throw ANOTHER
exception, (with a higher level message attached to it describing in
more application-friendly language what went wrong).

--
Canadian Mind Products, Roedy Green.
Coaching, problem solving, economical contract programming.
See http://mindprod.com/jgloss/jgloss.html for The Java Glossary.

Generally, I try to only have my method throw when its not possible
for my method to recover gracefully from an exception.

I use try, catch when I can recover from the exception...,  For
example, if you want to retry a database connection after one failed,
or you are doing math, and want to catch div by zero by just passing
back zero...

I try to also throw exceptions that mean something in its context. If
you are seperating your business logic from your data access, then you
might not want to have to catch SQLExceptions in your business logic.
In my data access logic, I capture SQLExceptions and convert to my
own.. YMMV, and its a preference thing (sometimes mandated by code
standards)

--
now with more cowbell

They're just two sides of the same coin.

For instance, notice that any code which can produce a *Checked*
Exception (as opposed to Unchecked) must eventually be bracketed in a
try-catch. Maybe not in its original method, but the method that calls
that method. Or maybe the try-catch block is 10 calls away in the stack
trace. At some point, somebody has to use try-catch to ensure that the
error gets handled.

The only reason for having the term "throws" in the java language is
that you, as the designer of a class, can decided *where* the try-catch
block should go. If an error occurs and its something you can handle
inside your class, then the try-catch should be inside your class.

On the other hand, if you're building a package for other developers to
use, there are probably going to be many instances where you want *them*
to write out the try-catch block in order to let them know when they've
made mistakes with the API. Thats when you would designate your methods
to throw a certain exception.

mehaase(at)sas(dot)upenn(dot)edu