short

The short data type in Java is a 16-bit signed two’s complement integer primitive. It occupies 2 bytes of memory and provides a numerically constrained alternative to the standard 32-bit int primitive.

Technical Specifications

• Size: 16 bits (2 bytes)
• Minimum Value: -32,768 ($-2^{15}$)
• Maximum Value: 32,767 ($2^{15} - 1$)
• Default Value: 0 (when declared as a class or instance variable)
• Wrapper Class: java.lang.Short

Syntax and Initialization

Integer literals in Java are of type int by default. The Java compiler performs implicit narrowing conversion from an int literal to a short variable, provided the literal is a compile-time constant and falls within the valid 16-bit range.

short minVal = -32768;
short maxVal = 32767;

// Compilation error: incompatible types: possible lossy conversion from int to short
// short outOfBounds = 32768; 

Type Promotion and Arithmetic

A critical language mechanic regarding short is numeric promotion. When applying arithmetic operators (+, -, *, /, %) or bitwise operators to short variables, the Java Virtual Machine (JVM) automatically promotes the operands to int before evaluating the expression.

Consequently, the result of the operation is an int, requiring an explicit downcast to assign it back to a short variable.

short a = 10;
short b = 20;

// Compilation error: incompatible types: possible lossy conversion from int to short
// short c = a + b; 

// Correct: Explicitly casting the int result back to short
short c = (short) (a + b); 

Compound assignment operators (e.g., +=, -=) handle this casting implicitly:

short d = 10;
d += 5; // Compiles successfully; equivalent to d = (short) (d + 5);

Casting Rules

• Widening (Implicit): A short can be implicitly cast to a larger or floating-point primitive (int, long, float, double) without data loss.
• Narrowing (Explicit): Casting a larger primitive down to a short requires an explicit cast. If the value exceeds the 16-bit capacity, the higher-order bits are discarded, resulting in a truncated, potentially altered value (underflow/overflow).

short s = 100;
int widened = s; // Implicit widening

int largeInt = 40000;
short narrowed = (short) largeInt; // Explicit narrowing. Result: -25536 (bit truncation)

Master Java with Deep Grasping Methodology!

Learn More