Why don't Java Number datatypes overflow?

Question

Why java Number / Numeric datatypes such as (Integer/Long/...) doesnt throw overflow exception? For example: We get mathematically wrong answer for following

Integer val = Integer.MAX_VALUE * 2;
System.out.println("Max val unexpected" + val);

** Max val unexpected-2**

I know; at the core these datatypes use primitive java datatypes. Still , isn't a good idea to prevent wrong answer by throwing something like..ValueOverflowException. Thought of extending and adding this behaviour but these all classes are final..

Please post your thoughts & opinions.

This isn't a discussion forum (see the FAQ). Questions like these that don't have a definitive answer don't really belong here. While it's not a bad question at all, it's not something that we can objectively answer for you; it's a design decision and you'd get a better answer on the Oracle forums. — Sasha Chedygov
– Sasha Chedygov, Commented Dec 27, 2010 at 6:03
@blob, is there any language that does this? think about that. — st0le
– st0le, Commented Dec 27, 2010 at 6:06
If you think a number might need to be larger than int allows, use a long, double, BigInteger or BigDecimal. This is a much simpler solution. Also don't use an Integer when you mean to use an int value. — Peter Lawrey
– Peter Lawrey, Commented Dec 27, 2010 at 8:52
@Peter Lawrey Thanks for the comment ;You are right; I just wanted to get opinions / thoughts over throwing an ValueOverflowException is better than wrong results. — Dhananjay
– Dhananjay, Commented Dec 27, 2010 at 15:56

Michael Aaron Safyan · Accepted Answer · 2010-12-27 06:05:50Z

9

Those types are just wrappers for the primitive types, and so it would be unexpected if they behaved differently. One reason those types do not throw those exceptions is that it would be incredibly costly if such checks were performed, and these integral types on the processor don't trigger interrupts when they overflow (whereas, by contrast, the floating point types can trigger interrupts for various events). If you are looking to support arbitrary precision, then you might be interested in the BigInteger type.

answered Dec 27, 2010 at 6:05

Michael Aaron Safyan

96k16 gold badges140 silver badges200 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Edwin Buck · Accepted Answer · 2013-12-09 15:08:45Z

The data types do overflow, your example proves it. What they do not do is throw an exception when overflowing.

In Java an Exception generally must be declared, and in doing so, must be caught. Yes, there are some scenarios where this doesn't hold (Errors, RuntimeExceptions, etc.) but such rules hold fast for the MAJORITY of exceptions.

If you wanted a MathOverflowException, then you would need to catch it. Otherwise it would serve no purpose. That would mean you would need to write code that looked like this

try {
  int x = 5 + 7;
} catch (MathOverflowException e) {
  // do something
}

Now this is where it gets really nasty. What "throws" the exception? It must be the "plus" sign, right? Well, only sort of. Methods on Objects throw exceptions, so that would mean the plus sign would have to be a "method" on the "object" 5. Except that in this special mathimatcal case, you don't dereference the method on the object; otherwise it would look like:

try {
  int x = 5.+ 7; // Note the dot-plus ".+"
} catch (MathOverflowException e) {
  // do something
}

But if you started doing this, then you need parenthesis for the operation.

try {
  int x = 5.+(7);
} catch (MathOverflowException e) {
  // do something
}

And doing so would imply that the assignment "equals sign" is also a method.

try {
  int x.=(5.+(7));
} catch (MathOverflowException e) {
  // do something
}

but we didn't create a "new" x, so it needs to be:

try {
  (new int x()).=(5.+(7));
} catch (MathOverflowException e) {
  // do something
}

or possibly

try {
  new int x(5).+(7);
} catch (MathOverflowException e) {
  // do something
}

Either way, it's a far trip from the simple algebra style, and Java decided to keep the well known algebra / C-ish / Fortran-ish syntax. In doing so, they quickly discovered that either they would need to make hidden "behind the scenes" rules to support math syntax in an object-oriented manner, or they would just need to dispense with the pretence that their math was object-oriented. They chose the latter.

Jonathan B · Accepted Answer · 2010-12-27 06:12:21Z

3

That is the way the specification says it works. Check 4.2 - Primitive Types And Values in the Java Specification for more information.

answered Dec 27, 2010 at 6:12

Jonathan B

1,0716 silver badges11 bronze badges

3 Comments

Ishtar Over a year ago

Or section 15.17.1, last line states

Despite the fact that overflow, underflow, or loss of information may occur, evaluation of a multiplication operator * never throws a run-time exception.

Dhananjay Over a year ago

accepted !! but it would have been more helpful if such operations throw an exception rather than wrong result.That's why was asking about getting an general opinion about it.

Jonathan B Over a year ago

It's a tricky call. I agree, it would be more helpful to have an exception for these conditions, but that would mean additional tests and would take more CPU time. The best solution, IMHO, would be a JVM switch that enables exceptions for overflow. That way you, the user, gets to decide if they want slower but more safe.

Collectives™ on Stack Overflow

Why don't Java Number datatypes overflow?

3 Answers 3

Comments

Comments

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related