“throws”与方法名称和捕获异常有什么区别？

Question

I am very new to exception handling in java, hence this question might seems stupid but please let it be answered. Suppose i have a method A in which some part of code can throw an exception B then what is the difference between catching the exception in the method or writting the method declaration as:-

void A() throws B{
     ----//----
     }

Answer 1

The difference lies in the way you call the method.

1. If your method signature says throws Exception , the code that calls your method must deal with the Exception either by catching it [via a catch clause] or throw it back [via throws clause].

2. If you catch the Exception , you are basically trying to handle the Exception yourself and the code that calls your method does not have to deal with the Exception .

My advice is as follows:

1. If you think you can handle and recover from the Exception , that you should catch and do the needful.

2. If you cannot deal with the Exception properly that do not catch it, you must throw it back.

NOTE: It is a bad programming style to catch an Exception and re-throw it back [although you can do it]. If you wrap the Exception with another one, then it is ok. But in this case it must make sense to wrap the Exception with another one.

Update: The idea is, no matter what number of layers your application has, somebody has to deal with that throws Exception clause. You cannot just let a StackTrace appear to the user in the middle of his activity with the application. The point to consider is "Can you recover from the error and resume your processing?" If yes, then handle the Exception, else throw it back to the layer that can at least show a meaningful message to the user about what happened.

Answer 2

If you catch the exception in A() you have to react to the error in your method A() , for example by trying the offending code again, logging the error, etc.

If you (re)throw the exception, you expect/forcce the method that called A() to handle the exception or it goes unhandled.

Answer 3

The difference is that if you catch B in the method body, you're handling the exception. You could throw another exception, but unless you do so the problem is considered solved as far as Java is concerned. By using the throws declaration on the method signature, you're indicating that your method can throw exceptions of type B and other pieces of code using it will be forced to deal with it, or throw it further up.

Answer 4

What you wrote is merely an exception specification , which tells everyone which exceptions you may possibly throw. That doesn't mean that you will actually end up throwing any exceptions.

On the other hand, try / catch is about exception handling : You surround code in a try block which may throw an exception and then handle the exceptions as they come in.

From inside your class A you are only allowed to throw exceptions which are listed in the exception specification; if A derives from another class or interface, A s specification must be at least as restrictive as that of the base.

Answer 5

When you throw the exception you are "throwing" it back to the caller of that method.

On the other hand "catching" it with a try-catch block allows you to handle it within the method.

try {
//Do your stuff here
}

catch (Exception ex) {
System.out.println("I just caught exception = " + ex);
}

Answer 6

Catching the exception means you handle it, and should be done if you can recover from the exception, or you want to rethrow another exception.

Throwing the exception means letting the caller deal with it, should be used in any other case.

I would suggest you follow this lesson .

Answer 7

If you catch the exception in the method, you are essentially handling it (even if you do nothing with it) and the caller may not (necessarily) be aware; otherwise you are indicating to callers of the method what can go wrong, and what errors they're expected to handle, and if they don't handle it, then their application will certainly make them aware when the exception occurs.

Answer 8

When you are catching the exception it means that you'll handle the exception somehow in your catch-part. But when you are declaring that A() throws B you simply tell that A()-function might throw a B-exception. So when somebody is using A()-function he knows that he must handle the B-exception or throw it forward.

Answer 9

1. Catching the Exception is: You are providing a placeholder for handling the exceptional situation. So if any part of code in try block throws this exception, it will come to the catch block and the piece of code will be executed.

2. Throwing Exception is : You are not handling the exception. So if the code in the method which throws exception in header, creates the mentioned exception, it will be thrown to the method stack. so if code is like :

 method1() { x.method2(); } method2() { method3(); } method3() throws SomeException { ..... ...... } 

Then if the code in method3 throws SomeException, that will be propagated to method2, if method2 also does not handle the exception then to method1, likewise, up in the method stack.