Menu
Possible Duplicate:
Is 1/0 a legal Java expression?
Why does this code compile?
class Compiles {
public final static int A = 7/0;
public final static int B = 10*3;
public static void main(String[] args) {}
}
If I take a look in the compiled class file, I can see that B has been evaluated to 30, and that A still is 7/0.
As far as I understand the JSL an expression where you divide by zero is not a constant.
Ref: JLS 15.28
My above statement is due to this line:
A compile-time constant expression is an expression denoting a value of primitive type
Hence dividing by zero is not evaluated to a primitive value.
What I really dont understand is why the compiler allows this anyway? Just to be clear, my code above crashes runtime with a "java.lang.ExceptionInInitializerError"
As it seems to me the compiler threats any final static variable as a constant and evaluates it compile time. That means that the compiler already has tried to evaluate A, but since it was a division by zero it just let it go through. No compile time error. But this seems very very bizarre... The compiler knows it is a divide by zero and that it will crash runtime but nevertheless it doesn't flag a compile error!
Can anyone explain to me why?
831
Compile-time errors occur when there are syntactical issues present in application code, for example, missing semicolons or parentheses, misspelled keywords or usage of undeclared variables. These syntax errors are detected by the Java compiler at compile-time and an error message is displayed on the screen.
A compile time error is an error that is detected by the compiler. Common causes for compile time errors include: Syntax errors such as missing semi-colon or use of a reserved keyword (such as 'class'). When you try and access a variable that is not in scope.
A compile-time error generally refers to the errors that correspond to the semantics or syntax. A runtime error refers to the error that we encounter during the code execution during runtime. We can easily fix a compile-time error during the development of code. A compiler cannot identify a runtime error.
One of the most common run-time error is division by zero also known as Division error. These types of error are hard to find as the compiler doesn't point to the line at which the error occurs.
To throw an java.lang.ExceptionInInitializerError is the only correct behavior.
If your code did not compile, a perfectly valid Java program would have been rejected, and that would have been a bug.
The only correct alternative to putting 7/0 in the compiled code, would actually be to explicitly throw a ExceptionInInitializerError, but how much more useful is that?
The compiler knows it is a divide by zero and that it will crash runtime but nevertheless it does flag a compile error!
Actually, I wouldn't agree with that... would this program crash?
class Compiles {
public final static int A = 7/0;
public final static int B = 10*3;
public static void main(String[] args) {}
}
public class Test {
// Application entry point.
public static void main(String[] args) {
try {
new Compiles();
launchTheMissiles();
} catch (ExceptionInInitializerError e) {
doUsefulStuff();
}
}
}
JLS 15.28 Constant Expression:
A compile-time constant expression is an expression denoting a value of primitive type or a String that does not complete abruptly and is composed using only the following:
...
Therefore 7/0 is not a compile-time constant, since its evaluation completes abruptly due to division by zero. So, it's treated as a regular run-time expression, and throws an exception in runtime.
41
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
