Thread: Netbeans and Eclipse compiler's output is different. My book's output is too...

Hi,
I was trying to execute the following codes, but the something that I don't undestand was happen. The program was compiled differently according to ouput picture of the program in my java book. Furthermore, then I tried to compile the program in eclipse and NetBeans. I saw that all of output are different each other. I think output of the book is sensible, but I couldn't see this output on the compilers. Can anybody explain this stutation? What is the problem?

package finallyblock;
 
public class FinallyBlock {
    public static void main(String[] args) {
        try{
            throwException();
        }
        catch(Exception exception){
            System.err.println("Exception handled in main");
        }
 
        doesNotThrowException();
    }
 
    public static void throwException() throws Exception{
        try{
            System.out.println("Method throwException");
            throw new Exception();
        }
        catch(Exception exception){
            System.err.println("Exception handled in method throwException");
        }
        finally{
            System.err.println("Finally executed in throwException");
        }
    }
 
    public static void doesNotThrowException(){
        try{
            System.out.println("Method doesNotThrowException");
        }
        catch(Exception exception){
            System.err.println(exception);
        }
        finally{
            System.err.println("Finally executed in doesNotThrowException");
        }
 
        System.out.println("End of method doesNotThrowException");
    }
}

The output In My Book:
Method throwException
Exception handled in method throwException
Finally executed in throwException
Exception handled in main
Method doesNotThrowException
Finally executed in doesNotThrowException
End of method doesNotThrowException


The output On NetBeans:
Method throwException
Method doesNotThrowException
Exception handled in method throwException
End of method doesNotThrowException
Finally executed in throwException
Finally executed in doesNotThrowException



The output On Eclipse:
Method throwException
Exception handled in method throwException
Finally executed in throwException
Method doesNotThrowException
End of method doesNotThrowException
Finally executed in doesNotThrowException

As far as I understand the code the eclipse output is correct.
The output from your book is not correct because the exception that was thrown in the method throwException() will never reach the main method since it is already caught in the method itself.
So the text "Exception handled in main" should never be printed.

Why the output from netbeans is so different I can not explain. This would only make sense if you used multithreading which you obviously dont. At least judging from the code you've posted.

Originally Posted by hefese

Firstly I cannot believe that my book is not correct, but you said that "'Exception handled in main' should never be printed." and I think it is sensible. Secondly I learnt the reason of different ouputs on the compilers from another forum. According to a user from coderanch forum, the reason is that: "the reason is because you're writing some messages to System.out, and some messages to System.err. These streams are being flushed at unpredictable times, so their output may appear in random order in respect to each other."

This is likely, and is an example of undefined behaviour -- that is to say, it isn't accurate to say that any of the runtime environments you mention are doing anything "correctly".

But, you can prove it. System.out is a PrintStream, and PrintStream is Flushable. Invoking .flush() at every turn will essentially turn buffering off.

BTW, this aspect of buffering is why logging is not a dependable timing mechanism.

Originally Posted by hefese

Edit:
Sorry, I noticed that I wrote the code incomplete. I must add a line to the program above:

throw exception; // inside catch block in throwException() function

If you add this line to your code then what your book says would be correct. Because now your are re-throwing the exception and it will reach main.

By the way, books can have lots of errors, there are so many hands which a book has to go through until it is printed, it can easily happen that somebody messed up at some point. We are all just human.

Okay, thank you guys for your replies.