无符号扩展 vs. 有符号扩展

short 和 int 都是 Java 中的整数类型，但它们的存储大小不同：

• short: 16 位（2 字节）
• int: 32 位（4 字节）

当从 short 转换为 int 时，本质上是将一个 16 位的值放入一个 32 位的“容器”中，这里的关键在于如何填充那多出来的 16 位，Java 中的整数都是有符号的，遵循二进制补码表示法。

转换规则是符号扩展：

1. 查看原始 short 值的最高位（第 15 位）。
2. 如果最高位是 0（表示正数），则在 int 的高 16 位全部填充 0。
3. 如果最高位是 1（表示负数），则在 int 的高 16 位全部填充 1。

这样做可以确保转换后的 int 值与原始 short 值在数学上是相等的。

示例：

• 正数转换： short s = 12345; (二进制: 0011 0000 0011 1001) 转换为 int 后，前面补 0： int i = 0000 0000 0000 0000 0011 0000 0011 1001; (十进制仍为 12345)

• 负数转换： short s = -12345; (二进制补码: 1100 1111 1100 0111) 转换为 int 后，前面补 1： int i = 1111 1111 1111 1111 1100 1111 1100 0111; (十进制仍为 -12345)

转换方式

在 Java 中，这种转换是自动的，你不需要做任何显式操作，这被称为自动类型提升或隐式类型转换。

隐式转换（自动转换）

这是最常见、最简单的方式，当一个 short 类型的值被用在需要一个 int 类型的地方时，Java 编译器会自动为你完成转换。

场景：

• 赋值给 int 变量
• 在算术运算中
• 作为方法参数传递（当方法期望 int 时）

代码示例：

public class ShortToIntConversion {
    public static void main(String[] args) {
        short myShort = 100;
        // 1. 直接赋值给 int 变量
        // Java 自动进行符号扩展
        int myInt = myShort;
        System.out.println("隐式转换 (赋值):");
        System.out.println("myShort = " + myShort);      // 输出: 100
        System.out.println("myInt = " + myInt);          // 输出: 100
        System.out.println("myInt 的二进制表示: " + Integer.toBinaryString(myInt));
        // 输出: myInt 的二进制表示: 1100100 (前面有24个0，省略了)
        System.out.println("--------------------");
        // 2. 在算术运算中
        short anotherShort = 200;
        // 在计算时，myShort 和 anotherShort 都会被自动提升为 int
        int result = myShort + anotherShort;
        System.out.println("隐式转换 (算术运算):");
        System.out.println("result = " + result); // 输出: 300
        System.out.println("--------------------");
        // 3. 负数示例
        short negativeShort = -50;
        int negativeInt = negativeShort;
        System.out.println("隐式转换 (负数):");
        System.out.println("negativeShort = " + negativeShort); // 输出: -50
        System.out.println("negativeInt = " + negativeInt);   // 输出: -50
        System.out.println("negativeInt 的二进制表示: " + Integer.toBinaryString(negativeInt));
        // 输出: negativeInt 的二进制表示: 11111111111111111111111111001110
        // 可以看到高位被1填充了
    }
}

显式转换（强制类型转换）

虽然隐式转换已经足够,但你也可以使用强制类型转换符 (int) 来明确表示你的意图，这在代码中可以增强可读性，或者在某些复杂的表达式中让逻辑更清晰。

语法： int targetVariable = (int) sourceShortVariable;

代码示例：

public class ExplicitShortToInt {
    public static void main(String[] args) {
        short myShort = 255;
        // 使用强制类型转换，虽然在这里是多余的
        int myInt = (int) myShort;
        System.out.println("显式转换:");
        System.out.println("myShort = " + myShort); // 输出: 255
        System.out.println("myInt = " + myInt);   // 输出: 255
        // 在复杂表达式中使用，可以明确意图
        int a = 10;
        short b = 20;
        int result = (int) (a + b); // 虽然 a+b 已经是 int，但 (int) 强调了结果类型
        System.out.println("result = " + result); // 输出: 30
    }
}

注意事项和特殊情况

与 char 类型的转换

char 类型是 16 位的无符号整数，范围是 0 到 65535，将 char 转换为 int 时，采用的是零扩展（高位补 0），而不是符号扩展。

char myChar = 'A'; // ASCII码是65
int myIntFromChar = myChar; // 自动转换，高位补0
System.out.println(myIntFromChar); // 输出: 65
char myChar2 = (char) 65535; // char的最大值
int myIntFromChar2 = myChar2;
System.out.println(myIntFromChar2); // 输出: 65535

溢出问题（从 int 到 short）

虽然你的问题是 short 转 int，但了解其逆过程——int 转 short——非常重要，因为它涉及到数据溢出。

当将一个 int 值转换为 short 时，int 的值超出了 short 的表示范围（-32,768 到 32,767），高位会被截断，导致数据丢失和溢出。

int bigInt = 32768; // 比 short 的最大值 32767 大 1
short myShort = (short) bigInt; // 必须强制转换
// 32768 的二进制是 1000 0000 0000 0000
// 当被截断为 16 位时，它变成了 short 的最小值 -32768
System.out.println("原始 int 值: " + bigInt);       // 输出: 32768
System.out.println("转换后的 short 值: " + myShort); // 输出: -32768 (溢出!)

核心要点：

1. short 转 int 是安全的，不会导致数据丢失，因为 int 的范围完全覆盖了 short。
2. 这种转换是自动的，由 Java 编译器完成，遵循符号扩展原则。
3. 在大多数情况下,你不需要写显式的 (int) 强制转换，但使用它可以提高代码的可读性。
4. 需要警惕的是反向转换（int 转 short），这必须使用强制转换，并且存在数据溢出的风险。