7.2 Ap0020: self-assessment, assignment and arithmetic operators  (Page 8/11)

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.

Back to Question 9

Answer 8

B. Runtime Error

Explanation 8

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:

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

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.)

Back to Question 8

Answer 7

E. 33

Explanation 7

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,

• the integer operand will be converted to the floating type,
• the result will be of the floating type, and
• the fractional part of the result will be preserved to some degree of accuracy

Back to Question 7

Answer 6

D. -2147483647

Explanation 6

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 .