如何在 Java 中检查一个数字是否为双精度浮点数

简介

在这个实验中，你将学习如何在 Java 中判断一个数字是否为双精度浮点数（double）。我们将探索不同的技术，首先使用 instanceof 运算符检查一个对象是否为 Double 包装类的实例。

接下来，你将学习如何将字符串解析为双精度浮点数，并处理可能出现的错误。最后，我们将介绍如何区分 Double 和 Integer 类型，以确保你使用的是正确的数值表示。

Skills Graph

检查是否为 Double 类的实例

在这一步中，我们将探索 Java 中的 Double 类，并学习如何检查一个对象是否为该类的实例。在 Java 中，像 double 这样的基本数据类型都有对应的包装类，比如 Double。Double 类提供了一些处理双精度浮点数的实用方法。

首先，在你的 ~/project 目录下创建一个名为 DoubleCheck.java 的新 Java 文件。你可以使用左侧 WebIDE 的文件资源管理器来完成此操作。在 ~/project 目录下右键单击，选择“新建文件”，然后输入 DoubleCheck.java。

现在，在编辑器中打开 DoubleCheck.java 文件，并添加以下代码：

public class DoubleCheck {
    public static void main(String[] args) {
        // Declare a primitive double variable
        double primitiveDouble = 123.45;

        // Declare a Double object
        Double doubleObject = 67.89;

        // Declare an Integer object
        Integer integerObject = 100;

        // Check if primitiveDouble is an instance of Double (This will not work directly)
        // System.out.println("Is primitiveDouble an instance of Double? " + (primitiveDouble instanceof Double)); // This line would cause a compile error

        // Check if doubleObject is an instance of Double
        System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));

        // Check if integerObject is an instance of Double
        System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
    }
}

在这段代码中：

• 我们声明了一个基本 double 类型的变量 primitiveDouble。
• 我们声明了一个 Double 对象 doubleObject。
• 我们声明了一个 Integer 对象 integerObject 用于比较。
• 我们使用 instanceof 运算符来检查 doubleObject 和 integerObject 是否为 Double 类的实例。
• 注意，instanceof 运算符不能直接用于像 double 这样的基本类型。

保存 DoubleCheck.java 文件。

现在，让我们编译并运行这个程序。打开 WebIDE 底部的终端。确保你位于 ~/project 目录下。

使用 javac 编译代码：

javac DoubleCheck.java

如果没有编译错误，使用 java 运行编译后的代码：

java DoubleCheck

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

Is doubleObject an instance of Double? true
Is integerObject an instance of Double? false

这个输出证实了 doubleObject 是 Double 类的实例，而 integerObject 不是。这展示了如何在 Java 中使用 instanceof 运算符来检查对象的类型。

将字符串解析为双精度浮点数

在这一步中，你将学习如何在 Java 中将表示数字的 String 转换为 double 类型的值。当你以文本形式接收数值输入时，例如从用户输入或从文件中读取，这是一项常见的任务。Double 类提供了一个名为 parseDouble() 的静态方法，专门用于此目的。

在你的 ~/project 目录下创建一个名为 StringtoDouble.java 的新 Java 文件。使用 WebIDE 的文件资源管理器来创建此文件。

打开 StringtoDouble.java 并添加以下代码：

public class StringtoDouble {
    public static void main(String[] args) {
        // A string representing a double value
        String doubleString = "987.65";

        // Another string representing a double value
        String anotherDoubleString = "3.14159";

        // A string that is not a valid double
        String invalidDoubleString = "hello";

        // Parse the strings to double values
        try {
            double parsedDouble1 = Double.parseDouble(doubleString);
            double parsedDouble2 = Double.parseDouble(anotherDoubleString);

            System.out.println("Parsed double from \"" + doubleString + "\": " + parsedDouble1);
            System.out.println("Parsed double from \"" + anotherDoubleString + "\": " + parsedDouble2);

            // Attempt to parse an invalid string (This will cause an error)
            // double parsedDouble3 = Double.parseDouble(invalidDoubleString);
            // System.out.println("Parsed double from \"" + invalidDoubleString + "\": " + parsedDouble3);

        } catch (NumberFormatException e) {
            System.out.println("Error parsing string: " + e.getMessage());
        }
    }
}

在这段代码中：

• 有两个字符串 doubleString 和 anotherDoubleString，它们包含有效的双精度数字表示。
• 还有一个 invalidDoubleString，它不表示有效的数字。
• 使用 Double.parseDouble() 方法将有效的字符串转换为 double 基本类型的值。
• 将解析代码放在 try-catch 块中。这很重要，因为如果字符串无法解析为有效的双精度数（如 invalidDoubleString），parseDouble() 方法将抛出 NumberFormatException 异常。catch 块会优雅地处理此错误。

保存 StringtoDouble.java 文件。

现在，编译并运行该程序。打开终端，确保你位于 ~/project 目录下。

编译代码：

javac StringtoDouble.java

运行编译后的代码：

java StringtoDouble

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

Parsed double from "987.65": 987.65
Parsed double from "3.14159": 3.14159

如果你取消注释尝试解析 invalidDoubleString 的代码行并再次运行程序，你将看到 catch 块中的错误消息，这展示了程序如何处理无效输入。

这一步向你展示了如何将数字的字符串表示转换为实际的 double 值，这是在 Java 程序中处理输入的一项关键技能。

区分双精度浮点数和整数

在这一步中，你将学习如何在 Java 中区分 double 和 int（整数）类型的值，特别是在处理看似相似的数字时。double 类型可以表示带小数点的数字，也可以表示整数；而 int 类型只能表示整数。理解这种差异对于选择正确的数据类型和进行精确计算至关重要。

使用 WebIDE 的文件资源管理器，在你的 ~/project 目录下创建一个名为 NumberTypes.java 的新 Java 文件。

打开 NumberTypes.java 文件，并添加以下代码：

public class NumberTypes {
    public static void main(String[] args) {
        // An integer variable
        int integerValue = 10;

        // A double variable representing a whole number
        double doubleValueWhole = 20.0;

        // A double variable representing a number with a decimal part
        double doubleValueDecimal = 30.5;

        // Print the values and their types (implicitly)
        System.out.println("Integer value: " + integerValue);
        System.out.println("Double value (whole): " + doubleValueWhole);
        System.out.println("Double value (decimal): " + doubleValueDecimal);

        // Check the type using instanceof (for wrapper classes)
        Integer integerObject = 100;
        Double doubleObject = 200.0;

        System.out.println("Is integerObject an instance of Integer? " + (integerObject instanceof Integer));
        System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));
        System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
        System.out.println("Is doubleObject an instance of Integer? " + (doubleObject instanceof Integer));

        // Demonstrate potential issues with comparing double and int
        System.out.println("Is integerValue equal to doubleValueWhole? " + (integerValue == doubleValueWhole)); // This comparison works due to type promotion
        // System.out.println("Is integerValue equal to doubleValueDecimal? " + (integerValue == doubleValueDecimal)); // This would be false
    }
}

在这段代码中：

• 声明了一个 int 类型的变量 integerValue。
• 声明了两个 double 类型的变量，一个表示整数（doubleValueWhole），另一个带有小数部分（doubleValueDecimal）。
• 打印这些值，以便观察它们的表示形式。
• 使用 instanceof 运算符和包装类 Integer 与 Double 来显式检查对象类型，这与第一步的操作类似。
• 还展示了 int 类型和 double 类型之间的比较。Java 会进行类型提升，在比较之前将 int 类型转换为 double 类型，因此 integerValue == doubleValueWhole 的比较结果为 true。

保存 NumberTypes.java 文件。

现在，编译并运行该程序。打开终端，确保你位于 ~/project 目录下。

编译代码：

javac NumberTypes.java

运行编译后的代码：

java NumberTypes

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

Integer value: 10
Double value (whole): 20.0
Double value (decimal): 30.5
Is integerObject an instance of Integer? true
Is doubleObject an instance of Double? true
Is integerObject an instance of Double? false
Is doubleObject an instance of Integer? false
Is integerValue equal to doubleValueWhole? true

这个输出有助于说明 int 和 double 类型的值在存储和表示上的差异，以及如何使用它们的包装类和 instanceof 运算符来检查类型。虽然 double 类型可以存储整数值，但它本质上仍然是浮点类型，与整数类型不同。

总结

在本次实验中，你学习了如何在 Java 中检查一个数字是否为 Double 类型。首先，你了解了 Double 包装类，并使用 instanceof 运算符来判断一个对象是否为 Double 类的实例。你会发现，instanceof 运算符适用于 Double 对象，但不能直接用于基本数据类型 double。