如何在 Java 中检查整数是否在 short 类型范围内

介绍

在这个实验中，你将学习如何检查一个整数值是否在 Java 中 short 数据类型的范围内。我们将首先了解 short 定义的范围（-32768 到 32767），然后对照这些范围来验证整数值。最后，我们将探讨如何有效地处理边界值。

设置 short 类型范围（-32768 到 32767）

在这一步中，我们将探索 Java 中的 short 数据类型，并了解其范围。在编程中，数据类型用于对变量可以存储的不同类型的数据进行分类。short 数据类型是一个 16 位有符号的二进制补码整数。这意味着它可以在特定范围内存储整数，包括正数和负数。

Java 中 short 的范围是从 -32768 到 32767。了解这些范围对于避免像溢出或下溢这样的错误至关重要，当你尝试存储超出数据类型范围的值时，就会发生这些错误。

让我们创建一个简单的 Java 程序，来看看 short 数据类型的实际应用，并观察其范围限制。

如果 HelloJava.java 文件尚未在 WebIDE 编辑器中打开，请打开它。

将文件的全部内容替换为以下代码：

public class HelloJava {
    public static void main(String[] args) {
        // Declare and initialize a short variable
        short myShort = 10000;
        System.out.println("My short variable: " + myShort);

        // Demonstrate the maximum value of short
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Demonstrate the minimum value of short
        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);
    }
}

在这段代码中：

我们声明了一个 short 类型的变量 myShort，并将其赋值为 10000。
然后，我们声明了 maxShort 和 minShort，并分别为它们赋值为 short 所能存储的最大值和最小值。
我们使用 System.out.println() 将这些变量的值打印到控制台。

保存文件（Ctrl+S 或 Cmd+S）。
现在，让我们编译我们的程序。打开 WebIDE 底部的终端，并确保你位于 ~/project 目录中。如果不在该目录中，请使用命令 cd ~/project。然后，使用 javac 命令编译代码：
```
javac HelloJava.java
```
如果没有错误，编译将成功，并且会在 ~/project 目录中创建一个 HelloJava.class 文件。

最后，使用 java 命令运行编译后的程序：

java HelloJava

你应该会在终端中看到以下输出：

My short variable: 10000
Maximum short value: 32767
Minimum short value: -32768

这个输出证实了我们的 short 变量在定义的范围内保存了预期的值。在下一步中，我们将探索当我们尝试为其赋值超出这个范围的值时会发生什么。

对照 short 类型范围验证整数

在上一步中，我们了解了如何在有效范围内声明和使用 short 变量。现在，让我们来探索当我们尝试将超出 short 范围的值赋给 short 变量时会发生什么。

Java 有不同的整数数据类型，包括 byte、short、int 和 long，每种类型都有不同的范围。int（整数）是一个 32 位有符号的二进制补码整数，其范围从 -2147483648 到 2147483647。这个范围比 short 的范围大得多。

当你尝试将一个较大数据类型（如 int）的值赋给一个较小数据类型（如 short）时，Java 要求你明确告知它你已意识到可能会丢失信息。这被称为 类型转换。如果你不进行转换，Java 会给出编译错误，以防止意外的数据丢失。

让我们修改 HelloJava.java 程序来演示这一点。

在 WebIDE 编辑器中打开 HelloJava.java 文件。

将现有代码替换为以下代码：

public class HelloJava {
    public static void main(String[] args) {
        int largeInt = 40000; // This value is outside the short range

        // Attempt to assign largeInt to a short variable without casting
        // short myShort = largeInt; // This line will cause a compilation error

        // To assign a value from a larger type, we need to cast it
        short myShort = (short) largeInt;
        System.out.println("Value of largeInt cast to short: " + myShort);

        int anotherLargeInt = -40000; // Another value outside the short range
        short anotherShort = (short) anotherLargeInt;
        System.out.println("Value of anotherLargeInt cast to short: " + anotherShort);
    }
}

在这个更新后的代码中：

我们声明了一个 int 变量 largeInt，其值为 40000，这个值大于 short 所能容纳的最大值（32767）。
注释掉的代码行 short myShort = largeInt; 展示了不进行转换会发生什么——编译错误。
代码行 short myShort = (short) largeInt; 演示了如何将 int 值转换为 short。largeInt 前面的 (short) 就是转换运算符。
我们对负值 anotherLargeInt（-40000）也做了同样的操作，这个值小于 short 所能容纳的最小值（-32768）。

保存文件（Ctrl+S 或 Cmd+S）。
现在，在终端中编译修改后的程序：
```
javac HelloJava.java
```
这次，编译应该会成功，因为我们使用了类型转换。

运行编译后的程序：

java HelloJava

你会看到类似以下的输出：

Value of largeInt cast to short: -25536
Value of anotherLargeInt cast to short: 25536

注意，输出值（-25536 和 25536）并不是原始值（40000 和 -40000）。这是因为当你将超出目标数据类型范围的值进行转换时，值会“回绕”。这是溢出（正值超过最大值）和下溢（负值超过最小值）的一个例子。确切的结果值取决于数字在二进制中的表示方式。这说明了理解数据类型范围并谨慎使用类型转换以避免意外结果的重要性。

处理边界值

在前面的步骤中，我们了解了 short 数据类型的范围，以及当我们对超出该范围的较大整数值进行类型转换时会发生什么。理解 Java 如何处理恰好处于 short 范围边界的值（-32768 和 32767）也很重要。

当处理边界值时，你需要格外小心，尤其是在执行算术运算时。对最大值加 1 或对最小值减 1 可能会导致溢出或下溢，使值回绕到范围的另一端。

让我们最后一次修改 HelloJava.java 程序，来演示这种边界行为。

在 WebIDE 编辑器中打开 HelloJava.java 文件。

将现有代码替换为以下代码：

public class HelloJava {
    public static void main(String[] args) {
        short maxShort = 32767;
        System.out.println("Maximum short value: " + maxShort);

        // Adding 1 to the maximum short value
        // Note: The result of maxShort + 1 is an int by default
        int overflowInt = maxShort + 1;
        System.out.println("Maximum short + 1 (as int): " + overflowInt);

        // Casting the overflowed int back to short
        short overflowShort = (short) overflowInt;
        System.out.println("Maximum short + 1 (cast to short): " + overflowShort);

        short minShort = -32768;
        System.out.println("Minimum short value: " + minShort);

        // Subtracting 1 from the minimum short value
        // Note: The result of minShort - 1 is an int by default
        int underflowInt = minShort - 1;
        System.out.println("Minimum short - 1 (as int): " + underflowInt);

        // Casting the underflowed int back to short
        short underflowShort = (short) underflowInt;
        System.out.println("Minimum short - 1 (cast to short): " + underflowShort);
    }
}

在这段代码中：

我们从 short 的最大值 (maxShort) 开始。
我们对 maxShort 加 1。默认情况下，涉及 short（和 byte）的算术运算会提升为 int 类型。因此，maxShort + 1 的结果是一个 int 类型的值，我们将其存储在 overflowInt 中。
然后，我们将 overflowInt 强制转换回 short 类型，并将其存储在 overflowShort 中。这时就会发生溢出，值会回绕。
我们对 short 的最小值 (minShort) 进行类似的操作，通过减 1 来演示下溢。

保存文件（Ctrl+S 或 Cmd+S）。
在终端中编译程序：
```
javac HelloJava.java
```

运行编译后的程序：

java HelloJava

你应该会看到类似以下的输出：

Maximum short value: 32767
Maximum short + 1 (as int): 32768
Maximum short + 1 (cast to short): -32768
Minimum short value: -32768
Minimum short - 1 (as int): -32769
Minimum short - 1 (cast to short): 32767

如你所见，当我们对 short 的最大值（32767）加 1 并将结果强制转换回 short 类型时，值会回绕到最小值（-32768）。同样，对 short 的最小值（-32768）减 1 并将结果强制转换回 short 类型时，值会回绕到最大值（32767）。

在使用像 short 这样的固定大小整数类型时，记住这种行为很重要。始终要留意数据类型的范围，以防止因溢出或下溢而导致意外结果。

总结

在本次实验中，我们学习了 Java 中的 short 数据类型，了解了它是 16 位有符号的二进制补码类型，以及其特定的取值范围从 -32768 到 32767。我们探讨了如何声明和初始化 short 变量，并通过一个简单的 Java 程序展示了它所能容纳的最大值和最小值。这一基础步骤对于在该范围内处理整数值时避免潜在的溢出或下溢错误至关重要。