Primitive type ‘short’ – casting in Java

by

As explained in short C# (but also for other language compilers as well, like Java)

There is a predefined implicit conversion from short to int, long, float, double, or decimal.

You cannot implicitly convert nonliteral numeric types of larger storage size to short (see Integral Types Table for the storage sizes of integral types). Consider, for example, the following two short variables x and y:

short x = 5, y = 12;

The following assignment statement will produce a compilation error, because the arithmetic expression on the right-hand side of the assignment operator evaluates to int by default.

short z = x + y;   // Error: no conversion from int to short

To fix this problem, use a cast:

short z = (short)(x + y);   // OK: explicit conversion

It is possible though to use the following statements, where the destination variable has the same storage size or a larger storage size:

int m = x + y;
long n = x + y;

A good follow-up question is:

“why arithmetic expression on the right-hand side of the assignment operator evaluates to int by default” ?

A first answer can be found in:

Classifying and Formally Verifying Integer Constant Folding

The Java language specification defines exactly how integer numbers are represented and how integer arithmetic expressions are to be evaluated. This is an important property of Java as this programming language has been designed to be used in distributed applications on the Internet. A Java program is required to produce the same result independently of the target machine executing it.

In contrast, C (and the majority of widely-used imperative and
object-oriented programming languages) is more sloppy and leaves many important characteristics open. The intention behind this inaccurate language
specification is clear. The same C programs are supposed to run on a 16-bit,
32-bit, or even 64-bit architecture by instantiating the integer arithmetics of
the source programs with the arithmetic operations built-in in the target processor. This leads to much more efficient code because it can use the available
machine operations directly. As long as the integer computations deal only
with numbers being “sufficiently small”, no inconsistencies will arise.

In this sense, the C integer arithmetic is a placeholder which is not defined exactly
by the programming language specification but is only completely instantiated by determining the target machine.

Java precisely defines how integers are represented and how integer arithmetic is to be computed. 

      Java Integers
--------------------------
Signed         |  Unsigned
--------------------------
long  (64-bit) |
int   (32-bit) |
short (16-bit) |  char (16-bit)
byte  (8-bit)  |

Char is the only unsigned integer type. Its values represent Unicode characters, from \u0000 to \uffff, i.e. from 0 to 216−1.

If an integer operator has an operand of type long, then the other operand is also converted to type long. Otherwise the operation is performed on operands of type int, if necessary shorter operands are converted into int. The conversion rules are exactly specified.

[From Electronic Notes in Theoretical Computer Science 82 No. 2 (2003)
Blesner-Blech-COCV 2003: Sabine GLESNER, Jan Olaf BLECH,
Fakultät für Informatik,
Universität Karlsruhe
Karlsruhe, Germany]

More Related Contents:

  1. How does double to int cast work in Java
  2. Cast primitive type array into object array in java
  3. Why don’t Java Generics support primitive types?
  4. explicit casting from super class to subclass
  5. What is short circuiting and how is it used when programming in Java? [duplicate]
  6. Is an array a primitive type or an object (or something else entirely)?
  7. Why does the ternary operator unexpectedly cast integers?
  8. Why does Java implicitly (without cast) convert a `long` to a `float`?
  9. How to cast a double to an int in Java by rounding it down?
  10. Java’s L number (long) specification
  11. Cast Int to enum in Java
  12. Converting characters to integers in Java
  13. Postgres data type cast
  14. How to insert a character in a string at a certain position?
  15. Can’t cast to to unspecific nested type with generics
  16. What is the priority of casting in java?
  17. Cast Object to Generic Type for returning
  18. How to cast List to List
  19. What is unchecked cast and how do I check it?
  20. Converting double to integer in Java
  21. How to serialize Java primitives using Jersey REST
  22. Comparator with double type
  23. 2 bytes to short
  24. How to avoid large if-statements and instanceof
  25. Casting LinkedHashMap to Complex Object
  26. Java casting in interfaces
  27. Why does the xor operator on two bytes produce an int?
  28. Which one to use, int or Integer
  29. What does int.class mean
  30. Why don’t Java’s +=, -=, *=, /= compound assignment operators require casting long to int?

Leave a Comment