System.exit(int) and javac def-use calculation

Question

I'm wondering if anyone can tell me why javac (J2SE v1.4.2) seems to ignore "System.exit(int)" (alternately, "Runtime.getRuntime().exit(int)") for the pursposes of determining possible variable access before an initialization.
For example, consider the following code:
/*01*/  public class C {
/*02*/    public void foo() throws Exception {
/*03*/      C obj;
/*04*/      while (true) {
/*05*/        try { obj = new C(); }
/*06*/        catch (Exception fault) { System.exit(1); }
/*07*/        obj.foo();
/*08*/      }
/*09*/    }
/*10*/  }Compile this (ignoring the absurdity of what "foo()" actually does), and you will get a variable obj might not have been initialized error. This despite the fact that a call to "System.exit(int)" never returns normally, by definition. To illustrate why this error doesn't make sense, substitute the "System.exit(1)" of line #6 with any of "break", "return", or "throw new Exception()". The use calculation for variable 'obj' is correct in these three alternate situations, but not for the first, even though the situation is analagous.
Obviously, there is an easy work-around to this (viz., change line #3 to "C obj = null;"), though it seems unnecessary. Any ideas?

Answer 1

System.exit() doesn't have the same "special" meaning
to the compiler as "break", "return", or "throw" do.
As far as the compiler sees, you are simply calling a
method in your exception handler; it doesn't know
that there will be no return from that method. Sure,
the compiler could special-case System.exit(), but
then you'd still see this same problem if you came up
with your own wrapper method that calls
System.exit().. the compiler in general doesn't (and
shouldn't) assume that a method call will terminate
the app.I understand that "System.exit(int)" is merely a method from the perspective of the compiler, but it is a rather special method (actually the "Runtime" version, for which the "System" version is merely a wrapper) with respect to correct program execution, calculated during the various traces that are done during compilation. And wrapping "System.exit(int)" with another method wouldn't make any difference to the calculation if it was considered, from the perspective of compilation, an uncaught (implicitly declared non-Runtime) exception. Besides, there must be some execution sequence within "Runtime.exit(int)" that serves, essentially, the same function as an "exit" keyword.
What's wrong with supplying a default value when you
declare the variable?Absolutely nothing, except that it isn't necessary. I typically do so anyway, and only came across this "feature" of javac during a lapse of my coding standards.