short Keyword Usage and Examples

Learn how the Java short keyword is used to declare 16-bit integer variables. Explore examples, memory efficiency, and use cases for beginners.

This reference explains short Keyword Usage and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

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.

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

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

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

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;

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.

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

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

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

• 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

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.