Why adding positive values in Java or C# sometimes result in a negative value?

Question

I was playing around with variables in Java.

public class Hello {
 public static void main(String[] args) {
 byte byteV = 127;
 short shortV = Short.MAX_VALUE;
 int intV = Integer.MAX_VALUE;
 System.out.println("Short: " + shortV + ", Integer: " + intV);
 long longV = (10 * byteV) + shortV + intV;
 System.out.println(longV);
 }
}

The longV variable prints out a negative number, even though all the other variables are positive. Why?

• Arseni Mourzenko: I edited your question and mentioned C# in the title, since code similar to yours rewritten in C# will produce the same result, for exactly the same reasons.
• Arseni Mourzenko: To the person who voted to close this question as "assistance in writing or debugging existing code", note that the question has nothing to do with debugging existing code, but understanding the underlying mechanisms of the language.
• CodesInChaos: C# has a compiler switch which tells it to throw an exception instead of wrapping when this happens. I strongly recommend enabling this switch, at least for your debug build.

Answer 1

Numeric overflow

That's how Java and similar languages handle numeric overflow. In order to illustrate it, you can write a much simpler code:

public static void main(String[] args)
{
 int intV = Integer.MAX_VALUE;
 System.out.println(intV + 1);
}

which would produce -2147483648 as a result.

An answer on StackOverflow explains what happens under the hood, "binary-speaking".

Note that doing this:

public static void main(String[] args)
{
 int intV = Integer.MAX_VALUE;
 long result = intV + 1;
 System.out.println(result);
}

since the intV + 1 part will be evaluated first, and only after that, the resulting value will be cast to a long. However, this would give a positive result, because the addition is now performed on a long value:

public static void main(String[] args)
{
 int intV = Integer.MAX_VALUE;
 long result = (long)intV + 1;
 System.out.println(result);
}

Specific handling of short

If you play with the first piece of code from my answer, you may end up writing code like this:

public static void main(String[] args)
{
 short shortV = Short.MAX_VALUE;
 System.out.println(shortV + 1);
}

You may be surprised to see that the result is 32768, which looks like nonsense since short can only store values from -32 768 to 32 767.

This is a particularity of Java (and similar languages such as C#) in a way the + operator works with short values. You can have a hint about what's going on by writing this piece of code:

public static void main(String[] args)
{
 short a = 5;
 short b = 4;
 short c = a + b;
 System.out.println(c);
}

This piece of code won't compile:

error: incompatible types: possible lossy conversion from int to short

What happens is that + operator first converts the short values to integers, and then produces the result. This is why in the piece of code above, you don't encounter a numeric overflow, since the addition is performed on an actual integer, and it's the value of an integer which is passed to println. On the other hand, this code:

public static void main(String[] args)
{
 short shortV = Short.MAX_VALUE;
 short result = (short)(shortV + 1);
 System.out.println(result);
}

will display -32768, because even if the addition itself resulted in 32768, the cast of 32768 to short produced a numeric overflow.

• Infinitibyte: Just like how Java converts the results to integers after arithmetic operations, notably the division operator, it's necessary to cast the variables I guess.