> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java 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.
```java theme={"dark"}
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.
```java theme={"dark"}
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:
```java theme={"dark"}
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).
```java theme={"dark"}
short s = 100;
int widened = s; // Implicit widening
int largeInt = 40000;
short narrowed = (short) largeInt; // Explicit narrowing. Result: -25536 (bit truncation)
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
