Java中的捕获与抛出异常

Question

So I have two general questions about java in general. The first is when would one use a try/catch in the body of the method versus using throws exception in declaring the method? Here is a little demonstration of what I mean. This:

public void whileChatting() throws IOException{}

versus

public void closeConnection() {
    try {
    } catch (IOException ioException) {
        ioException.printStackTrace();
    }
}

And then my second question is when does one know what type of exception to either catch or throw? By that I mean exceptions such as IOException or EOFException and so on...

If there's a good link someone could send me teaching all this (being that it's probably more complicated than I think) I would be just as grateful as if you answered it. Thanks.

Answer 1

Throwing Exceptions

In your first example,

public void whileChatting() throws IOException{}

means that it will just throw the exception to whatever is calling the function. It can then be caught while calling that method with a try-catch block. such as

try{
    whileChatting();
}
catch(IOException e){
    e.printStackTrace();
}

Throwing a method basically propagates it up the chain, and so any method that calls this method will need to also include throws IOException , or the exception will need to be dealt with in the higher level method (by means of a try-catch block usually).

Catching Exceptions

Catching an exception is a way to gracefully deal with exceptions. The common thing to do is e.printStackTrace(); which prints details of the error to the console, however it's not always necessary. Sometimes you may want to do a System.exit(0) or even a System.out.println("Error in method whileCalling()")

With a catch block you can catch any type of exception! you can also do a try-catch-finally block which will run the code in the try block, catch any exceptions, and whether or not any exceptions are caught it will enter the finally block and run that code.

To know what Exception you might need to catch, you can look at the Javadocs for the class that may throw the exception. There you will find a list of every possible thing that the class can throw. You can also just catch Exception which will catch any Exception imaginable! (Well, granted it extends Exception)

And finally you can link catch blocks together like so.

try{
    whileCalling();
}
catch(IOException e){
    //handle this situation
}
catch(FileNotFoundException e){
    //handle this situation
}
catch(Exception e){
    //handle this situation
}

This will work like and else-if block and not catch duplicates.

So to answer your questions basically:

1: To throw an Exception means to have somebody else deal with it, whether this be another class, another method, or just to hoping it doesn't happen or else your program will crash(pretty bad practice).

2: To use a try catch block is to actually deal with the Exception however you see fit! printing out the stacktrace for debugging or giving the user a new prompt to re-input something maybe. (For instance a prompt that the user needs to enter a file location and then it throws a FileNotFoundException )

Hope that helps!

Answer 2

Two good rules of thumb:

• You should only catch exceptions that you can actually handle

• Throw Early/Catch Late

There's no hard and fast answer.

In general, you'll probably use "throws" much more often than you'll have a custom "try/catch". Simply because you'll have relatively few "decision" modules that "know how to recover", but you'll have correspondingly "many" modules that could throw exceptions.

Answer 3

You use try/catch when you want to treat its reason, otherwise you should propagate it so it can be treated at the right time.

A good start would be javadoc and tutorialspoint for exceptions

Answer 4

Basically is something like this:

1. throws - the function that throws and exception tells it's parent function that somenthing it's wrong. For instance you have a createFunction() throws SQLException where you are trying to insert 100 item in a database but the creation of number 98 fails. The createFunction() is used in your main() who receives this SQLException;

2. try/catch - the main() knows that createFunction() is suppose to throw an SQLException if something goes wrong so when it implements it puts it in a try/catch block , this way if an SQLException is actually thrown you can execute a fall-back plan in the catch block such as a database rollback.

   Actual code of what I just said:

     createFunction(Connection connection) throws SQLException { //insert items in the database } main(){ try{ createFunction(connection); } catch (SQLException e){ connection.rollback(); } }