Common underflow and overflow exceptions

Question

I am trying to get a hold of overflow and underflow exceptions in java, but couldn't get any nice tutorial. Specifically I wish to learn

1. How are they different from each other?
2. What are the subclasses of these exceptions?
3. In which scenario they are thrown?
4. Which of them can be handled and how?
5. What are the best practice related to them?

Any link to useful tutorial will do

Answer 1

In Java arithmetic, overflow or underflow will never throw an Exception. Instead, for floating point arithmetic the value is set as Not a number, 'infinite' or zero.

To test for these you can use the static methods: isNaN or isInfinite using the appropriate wrapper classes. You can handle this as appropriate. Example:

double d1 = 100 / 0.;
if (Double.isNaN(d1)) {
    throw new RuntimeException("d1 is not a number");
}
if (Double.isInfinite(d1)) {
    throw new RuntimeException("d1 is infinite");
}

For certain operations you can get an ArithmeticException, for example when dividing by zero in Integer maths.

I just asked a related question about a complete project style way to handle this.

Answer 2

Okay, the OP talked about wanting to know about both stack overflow and arithmetic overflow, as well as their corresponding underflow. Here goes....

1. Arithmetic overflow happens when a number gets too big to fit in its value type. For example, an int holds values between -2³¹ and 2³¹-1, inclusive. If your number goes over these limits, an overflow occurs, and the number "wraps around". These do not cause an exception to be generated in Java.
2. Arithmetic underflow happens when a floating point number gets too small to distinguish very well from zero (the precision of the number got truncated). In Java, these do not cause an exception either.
3. Stack overflow happens when you call a function, that calls another function, that then calls another, then another...and the function call stack gets too deep. You get a StackOverflowError when that happens.
4. Stack underflow doesn't happen in Java. Its runtime system is supposed to prevent that sort of stuff from happening.

To answer the OP's other question (see comments), when you overstep the boundaries of an array, an IndexOutOfBoundsException is issued.