newbie: exception handling (and Eclipse)
Hello,
I wrote a class with few methods; inside them I work with IO and XMLReader; now, since I haven't managed the exceptions at all, Eclipse was compaining about that and suggested two thing: surround with try/catch blocks or to add throws declaration close to each method, like this:
Code:
String Element() throws IOException, XMLStreamException {
}
After add those two declaration, suddenly Eclipse wasn't complaining no more.
My question is:
1. I read that those declaration don't solve the exception handling BUT only remember to to coder that will use them that he has to manage the exceptions. Right this?
2. so I suppose I have to addtry/catch inside each method: they are five: do I need repeat 5 try/catch in each methods either I can put just one out of them? and Where?
thanks
Re: newbie: exception handling (and Eclipse)
You need to read a tutorial on Exception handling such as the Sun tutorial
Quote:
1. I read that those declaration don't solve the exception handling BUT only remember to to coder that will use them that he has to manage the exceptions. Right this?
Sort of. Declaring a method throws an exception is a way of passing the responsibility of handling the exception to the calling method - of course the calling method could also just throw it to it's calling method and so on. If a thrown exception propagates all the way up the call stack and no one has handled it, a stack trace is dumped to the console.
Remember that there is a class of exceptions called unchecked exceptions such as NullPointerException that a method does not need to declare it throws, but it may still throw them.
Quote:
so I suppose I have to addtry/catch inside each method: they are five: do I need repeat 5 try/catch in each methods either I can put just one out of them? and Where?
You only add try catch statements to methods that can usefully handle the particular exception. If the code can't do something sensible in response to the exception then it should throw it, if it does handle it then the calling method can't handle it as well unless the exception handler re-throws the exception.
It may also be the case that a method catches some but not all of the exceptions thrown to it - this is perfectly ok. In this type of situation your method declares it throws the remaining exceptions and it up to the calling method to handle them.
Sometimes the handling mechanism is the same for a number of different exceptions in which case, if they have a common super class, you can just catch the super class. But be careful doing this as you may inadvertently catch exceptions you didn't intend to.
Also the order of your catch statements is important, if your first catch statement is for a common super class followed by catch statements for sub classes then the sub class catch statements will never be called.
Re: newbie: exception handling (and Eclipse)
not sure to have understood; BTW, these 5 methods do basically the same operation: reader.next(); however, before to call the next() method, I cal the reader.hasNext() that sohould guarantee that reader.next() will never throws any exception; right, this?
Yes, in my opinion (as the methods do basically the same operation) the best way would be put try and catch outside them. I was thinking directly in th main() class. Is this awful?
Re: newbie: exception handling (and Eclipse)
What kind of Reader has next() and hasNext() methods? I know ResultSet, Scanner, and Iterator have next() methods, but no Readers.
It doesn't matter whether you've called hasNext() before next(), if the next() method is declared to throw exceptions, then you need to decide how to handle them. If it isn't, you don't need to.
[Note that in the case of Scanner, for example, the next() method isn't declared to throw exceptions - so you don't have to write code to deal with them. However, the API docs say that it can throw certain exceptions in some circumstances. These are RuntimeException subtypes, known as 'unchecked' exceptions because you're not obliged to handle them, but if you don't, and the exceptions are thrown, the application will terminate. Generally, you'd only put in code to catch and handle these exceptions if there's a possibility that your code might trigger them - e.g. multi-threaded code where perhaps the Scanner is being accessed by more than one process.]
You should put your catch code blocks at the closest point where you can handle the exception and do something useful, such as retrying the operation, or tidying up and abandoning the operation. Sometimes this will be in the same method that throws the exception, sometimes in the method that calls that method, and sometimes it will be the main method. Usually, by the time it reaches the main method, there's nothing to do but output an informative error message and quit.
As soon as we started programming, we found out to our surprise that it wasn't as easy to get programs right as we had thought. Debugging had to be discovered. I can remember the exact instant when I realized that a large part of my life from then on was going to be spent in finding mistakes in my own programs...
M. Wilkes
Re: newbie: exception handling (and Eclipse)
Quote:
Originally Posted by
dlorde
What kind of Reader has next() and hasNext() methods? I know ResultSet, Scanner, and Iterator have next() methods, but no Readers.
XMLStreamReader
Re: newbie: exception handling (and Eclipse)
As I said earlier the exception handler should be placed where it can do something useful, if that place is the main method then that's the place to put it.
The XMLStreamReader.next() method throws 2 exceptions the first is NoSuchElementException - but this only happens if the method is called when hasNext() returns false which you are already checking for, so you will never get this exception. The second is XMLStreamException which happens if there is an error processing the underlying XML source. There's probably not a lot you can do about this other than reporting the problem to the user so catch the exception in the code that responded to the user's request to read the XML stream.
Re: newbie: exception handling (and Eclipse)
Quote:
Originally Posted by
keang
As I said earlier the exception handler should be placed where it can do something useful, if that place is the main method then that's the place to put it.
The XMLStreamReader.next() method throws 2 exceptions the first is NoSuchElementException - but this only happens if the method is called when hasNext() returns false which you are already checking for, so you will never get this exception. The second is XMLStreamException which happens if there is an error processing the underlying XML source. There's probably not a lot you can do about this other than reporting the problem to the user so catch the exception in the code that responded to the user's request to read the XML stream.
OK. I just want to inform the user that something went wrong with the sintax of the file in input.
But my question was even this: is there a way to evoid duplication of code ? Since I have 5 methods with the same try/catch block, can I put this up (maybe in the Main class), and write just one try/catch clause?
Re: newbie: exception handling (and Eclipse)
If you'd read the link I gave you you would have seen you can put multiple statements in a single try block. So you just need to put all five methods calls within the one try block.
Re: newbie: exception handling (and Eclipse)
Quote:
Originally Posted by
keang
If you'd read the link I gave you you would have seen you can put multiple statements in a single try block. So you just need to put all five methods calls within the one try block.
Maybe my situation is a little different:
Code:
//Main
MyObject ob = new MyObject();
class MyObject {
public MyObject() {
method1();
}
public void Method1() throws IOException, XMLStreamException{
int event = xmlreader.next();
if (event == ...........................) {
method2();
..................
}
}
public void Method2() throws IOException, XMLStreamException{
int event = xmlreader.next();
if (event == ..................... ) {
method3();
..................
}
}
}
}
SO I repeat my question: must I put try/catch inside each MethodX either I can put one in main class?
Re: newbie: exception handling (and Eclipse)
Quote:
SO I repeat my question:
And I'll repeat my answer - read the tutorial and the information you have already been given.
Admittedly your code isn't how you had originally described it ie you didn't mention you were chaining the 5 method calls, but the information I gave in my first post explains what will happen if any of the methods throws an exception and the caller doesn't handle it. And dlorde and I both explained where you can put the exception handler.
There's more than enough information there for you to be able to work it out for yourself - and if you can't work it out write some code and see what happens.
Re: newbie: exception handling (and Eclipse)
I know you gave me link but I always do confusion with this. I suppose I could do:
Code:
//Main
MyObject ob = new MyObject();
class MyObject {
public MyObject() throws IOException, XMLStreamException {
try {
method1();
}
catch (XMLStreamException ex) {
}
catch ( IOException ex) {
}
}
public void Method1() throws IOException, XMLStreamException{
int event = xmlreader.next();
if (event == ...........................) {
method2();
..................
}
}
public void Method2() throws IOException, XMLStreamException{
int event = xmlreader.next();
if (event == ..................... ) {
method3();
..................
}
}
}
}
So method1 and method2 will propagate up the exception (if an exception occur) and the exception will be caught inside method1; with this reasoning I could put the try/catch inside the main class, I suppose.
is this right?
Re: newbie: exception handling (and Eclipse)
Quote:
So method1 and method2 will propagate up the exception (if an exception occur) and the exception will be caught inside method1; with this reasoning I could put the try/catch inside the main class, I suppose.
is this right?
As dlorde and I have both said you put the handler at the point at which you can do something useful and as close as possible to the place the exception is thrown. If your handler can do what you want it to do where you have it then leave it there - don't move further from the problem than you have to.
Having said that you haven't done anything useful in the code you have shown. You've just committed the cardinal sin of catching the exceptions and doing nothing at all, not even dumping the stack trace. This just hides the fact that the exception has even been thrown. Always do something in the catch block even if it is just calling the exception's printStackTrace() method.
Re: newbie: exception handling (and Eclipse)
Quote:
Originally Posted by
keang
As dlorde and I have both said you put the handler at the point at which you can do something useful and as close as possible to the place the exception is thrown. If your handler can do what you want it to do where you have it then leave it there - don't move further from the problem than you have to.
Having said that you haven't done anything useful in the code you have shown. You've just committed the cardinal sin of catching the exceptions and doing nothing at all, not even dumping the stack trace. This just hides the fact that the exception has even been thrown. Always do something in the catch block even if it is just calling the exception's printStackTrace() method.
you're right. My question was only if the try/catch will be "called" fine. In the try/catch I would put simply a message with System.exit(-1) because there's nothing to recover (the XML file is not well written).
I only wonder if in my case here above exceptions are unuseful! Is the meaning of exception just recovering something?
Yesterday I wa thinking this: If I don't put try/cach at all the program the program will arise exception (and this is bad); I thought that putting try/catch was even to avoid the program arises exceptions at all! I thought this, but now I suppose this was wrong! try/catch just helps to RECOVER (but the exception will arise anyway). Is that, please?
Re: newbie: exception handling (and Eclipse)
An exception is thrown when some exceptional situation has occurred. If you don't handle a thrown exception it will propagate all the way to your main method and the application will close unceremoniously and dump a stack trace to the console (This is only true for CLI applications like yours, it can be a little different in multi-threaded and GUI apps). The user will be left thinking your application has crashed ie is poorly written, rather than being told it's their data that is at fault.
Quote:
but now I suppose this was wrong! try/catch just helps to RECOVER (but the exception will arise anyway). Is that, please?
It depends what you mean by recover, if you mean handle an unusual circumstance then yes, if you mean to allow the program to continue running then no not necessarily.
There are plenty of cases where you can't do anything to continue execution but you can still use exception handling to do something sensible before the application terminates ie close down a database connection, write an entry to an error log file, inform the user what has happened etc.
Re: newbie: exception handling (and Eclipse)
Quote:
Originally Posted by
mickey0
XMLStreamReader
Ah, yes - thanks. That's a 'new' one in Java 6. Sadly, for technical reasons, I'm still restricted to Java 5 day-to-day... :cry:
There are only two kinds of programming languages: those people always bitch about and those nobody uses...
B. Stroustrup
Re: newbie: exception handling (and Eclipse)
Don't mess around with the architecture of your application just to use the same exception handling code. If there is no functional relation or dependency between method1 and method2, you should not be calling method2 inside method1. If you find you want to use the same code to handle the exceptions from three different methods, you can either the method calls inside a single try block with the common exception handling in the following catch block, or give each method its own try/catch and put the exception handling code into a separate method which you call from the individual catch blocks, e.g:
Code:
void outerMethod() {
...
try {
...
method1();
...
method2();
...
method3();
...
}
catch (FooException fe) {
... // handle Foo exceptions from the methods
}
catch (BarException be) {
... // handle Bar exceptions from the methods
}
}
// alternatively
void method1() {
try {
... // do method1 stuff
}
catch (FooException fe) {
handleFooException(fe); // call common handler
}
catch (BarException be) {
handleBarException(be); // call common handler
}
}
...
void handleFooException(FooException fe) {
... // common Foo exception handling code
}
... // etc.
However, in my experience, it's not often that the second technique (using common exception handler methods) is useful or necessary, because some variation on the first technique is usually sufficient.
The most important single aspect of software development is to be clear about what you are trying to build...
B. Stroustrup
Re: newbie: exception handling (and Eclipse)
There is good pictorial and text explanation of exception handling in Java at
http://bharatchhajer.blogspot.com/20...g-in-java.html . Its a good and complete overview of different situations and how to handle them.
Re: newbie: exception handling (and Eclipse)
Advertising your own blog site especially by passing it off as a good site you've found is not acceptable here ie by saying "There is good pictorial and text explanation of exception handling in Java at". If you have written a tutorial that might help the OP then say something like "I've written a tutorial on XXX that might help, you can find it at".
I've read your tutorial and ignoring the usual smattering of typos that all of us make when posting stuff, I didn't find it particularly easy to understand. Your comparison to a car journey isn't well explained and is not used consistently throughout the article. And finally, I disagree with your comment "Unchecked exceptions should never if handled, so the compiler does not force you to decide on its handling." Assuming you meant to say "should never be handled", this is wrong. Generally speaking unchecked exceptions are not handled but there are cases when when it is useful to handle them such as catching a NumberFormatException when parsing external data and converting it to a number.
