Java short Keyword
Usage and Examples

short Keyword in Java

In Java, the short keyword is a primitive data type used to store whole numbers in a smaller memory footprint than int. It’s ideal when memory efficiency is more important than the range of values.

What is the Range of short in Java?

The short type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767.

• Size: 2 bytes (16 bits)
• Minimum Value: -32,768
• Maximum Value: 32,767
• Default Value: 0

When Should You Use short?

The short type is rarely used in modern Java applications because today’s systems have ample memory. However, it can be useful in performance-critical applications like:

• Large arrays of numbers
• Mobile or embedded systems
• Memory-constrained environments

Declaring and Initializing a short Variable

public class ShortExample {
    public static void main(String[] args) {
        short temperature = 250;
        System.out.println("Current temperature is: " + temperature + "°C");
    }
}

Current temperature is: 250°C

Assigning Values Beyond the Range

Java will throw a compilation error if you try to assign a value outside the range of a short.

// Compilation Error: incompatible types
short distance = 40000;

Explicit Type Casting from int to short

If you need to store an int value into a short variable, it must be cast explicitly. But be careful—this can cause overflow.

public class TypeCastingExample {
    public static void main(String[] args) {
        int number = 40000;
        short result = (short) number;
        System.out.println("After casting: " + result);
    }
}

After casting: -25536

Explanation: The original int value (40000) overflows when stored in short, resulting in a negative number.

Using short in Arithmetic Operations

Arithmetic operations on short are internally promoted to int. So, storing the result back in short requires explicit casting.

public class ArithmeticExample {
    public static void main(String[] args) {
        short a = 1000;
        short b = 2000;
        // short sum = a + b; // Compilation error
        short sum = (short) (a + b);
        System.out.println("Sum: " + sum);
    }
}

Sum: 3000

Default Value of short

When a short variable is declared as a class member and not initialized, its default value is 0.

public class DefaultShort {
    static short value;
    public static void main(String[] args) {
        System.out.println("Default short value: " + value);
    }
}

Default short value: 0

Arrays of short

short arrays are a compact way to store a large number of small integers.

public class ShortArray {
    public static void main(String[] args) {
        short[] ages = {15, 18, 21, 30};
        for (short age : ages) {
            System.out.println("Age: " + age);
        }
    }
}

Age: 15
Age: 18
Age: 21
Age: 30

Key Takeaways

• short is a 16-bit signed integer
• Use it for memory efficiency in large datasets
• Be mindful of range overflow
• Explicit casting is often required during operations