<< Chapter < Page | Chapter >> Page > |
What is the actual value?
The actual value returned by this program is provided by a static final variable in the Double class named POSITIVE_INFINITY .
(There is also a value for NEGATIVE_INFINITY, which is the value that would be returned if one of the operands were a negative value.)
Is this a better approach?
Is this a better approach than throwing an exception as is the case for integer divide by zero?
I will let you be the judge of that.
In either case, you can test the right operand before the divide to assure that it isn't equal to zero.
Cannot use exception handling in this case
For floating divide by zero, you cannot handle the problem by using try-catch.
However, you can test the result following the divide to see if it is equal to either of the infinity values mentioned above.
B. Runtime Error
Dividing by zero
This program attempts to divide the int value of 11 by the int value of zero.
Integer divide by zero is not allowed
This produces a runtime error and terminates the program.
The runtime error is as follows under JDK 1.3:
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Worker.doMixed(Ap017.java:14)at Ap017.main(Ap017.java:6) |
Two ways to deal with this sort of problem
One way is to test the right operand before each divide operation to assure that it isn't equal to zero, and to take appropriate action if it is.
A second (possibly preferred) way is to use exception handling and surround the divide operation with a try block, followed by a catch block for the type
java.lang.ArithmeticException. |
The code in the catch block can be designed to deal with the problem if it occurs. (Exception handling will be discussed in a future module.)
E. 33
Integer truncation
This program illustrates the integer truncation that results when the division operator is applied to operands of the integer types.
The result of simple long division
We all know that when we divide 101 by 3, the result is 33.666666 with the sixes extending out to the limit of our arithmetic accuracy.
The result of rounding
If we round the result to the next closest integer, the result is 34.
Integer division does not round
However, when division is performed using operands of integer types in Java, the fractional part is simply discarded (not rounded) .
The result is the whole number result without regard for the fractional part or the remainder.
Thus, with integer division, 101/3 produces the integer value 33.
If either operand is a floating type ...
If either operand is one of the floating types,
D. -2147483647
Danger, integer overflow ahead!
This program illustrates a very dangerous situation involving arithmetic using operands of integer types. This situation involves a conditioncommonly known as integer overflow .
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?