Wie man prüft, ob eine Zahl in Java ein Double ist

Einführung

In diesem Lab werden Sie lernen, wie Sie feststellen können, ob eine Zahl in Java eine Fließkommazahl (double) ist. Wir werden verschiedene Techniken untersuchen, beginnend damit, zu prüfen, ob ein Objekt eine Instanz der Double-Wrapper-Klasse mithilfe des instanceof-Operators ist.

Danach werden Sie lernen, wie Sie einen String in eine Fließkommazahl umwandeln und potenzielle Fehler behandeln. Abschließend werden wir behandeln, wie Sie zwischen Double- und Integer-Typen unterscheiden können, um sicherzustellen, dass Sie mit der richtigen numerischen Darstellung arbeiten.

Skills Graph

Überprüfen der Instanz der Double-Klasse

In diesem Schritt werden wir die Double-Klasse in Java untersuchen und lernen, wie man prüft, ob ein Objekt eine Instanz dieser Klasse ist. In Java haben primitive Datentypen wie double entsprechende Wrapper-Klassen, wie z.B. Double. Die Double-Klasse bietet nützliche Methoden für die Arbeit mit Fließkommazahlen (double-precision floating-point numbers) an.

Zunächst erstellen wir eine neue Java-Datei namens DoubleCheck.java in Ihrem ~/project-Verzeichnis. Sie können dies über den Dateiexplorer der WebIDE auf der linken Seite tun. Klicken Sie mit der rechten Maustaste im ~/project-Verzeichnis, wählen Sie "Neue Datei" und geben Sie DoubleCheck.java ein.

Öffnen Sie jetzt die DoubleCheck.java-Datei im Editor und fügen Sie folgenden Code hinzu:

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));
    }
}

In diesem Code:

• Wir deklarieren eine primitive double-Variable primitiveDouble.
• Wir deklarieren ein Double-Objekt doubleObject.
• Wir deklarieren ein Integer-Objekt integerObject zum Vergleich.
• Wir verwenden den instanceof-Operator, um zu prüfen, ob doubleObject und integerObject Instanzen der Double-Klasse sind.
• Beachten Sie, dass der instanceof-Operator nicht direkt mit primitiven Typen wie double verwendet werden kann.

Speichern Sie die DoubleCheck.java-Datei.

Jetzt kompilieren und führen wir das Programm aus. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden.

Kompilieren Sie den Code mit javac:

javac DoubleCheck.java

Wenn es keine Kompilierungsfehler gibt, führen Sie den kompilierten Code mit java aus:

java DoubleCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe bestätigt, dass doubleObject eine Instanz der Double-Klasse ist, während integerObject es nicht ist. Dies zeigt, wie man den instanceof-Operator in Java verwendet, um den Typ eines Objekts zu prüfen.

Umwandeln eines Strings in eine Fließkommazahl (double)

In diesem Schritt werden Sie lernen, wie Sie in Java einen String, der eine Zahl repräsentiert, in einen double-Wert umwandeln. Dies ist eine häufige Aufgabe, wenn Sie numerische Eingaben als Text erhalten, beispielsweise von Benutzereingaben oder beim Lesen aus einer Datei. Die Double-Klasse bietet eine statische Methode namens parseDouble() speziell für diesen Zweck.

Erstellen Sie eine neue Java-Datei namens StringtoDouble.java in Ihrem ~/project-Verzeichnis. Verwenden Sie den Dateiexplorer der WebIDE, um diese Datei zu erstellen.

Öffnen Sie StringtoDouble.java und fügen Sie folgenden Code hinzu:

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());
        }
    }
}

In diesem Code:

• Wir haben zwei Strings, doubleString und anotherDoubleString, die gültige Darstellungen von Fließkommazahlen enthalten.
• Wir haben auch invalidDoubleString, der keine gültige Zahl repräsentiert.
• Wir verwenden Double.parseDouble(), um die gültigen Strings in primitive double-Werte umzuwandeln.
• Wir umschließen den Parsing-Code in einem try-catch-Block. Dies ist wichtig, denn wenn der String nicht in eine gültige Fließkommazahl umgewandelt werden kann (wie invalidDoubleString), wirft parseDouble() eine NumberFormatException. Der catch-Block behandelt diesen Fehler gracefully.

Speichern Sie die StringtoDouble.java-Datei.

Jetzt kompilieren und führen wir das Programm aus. Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden.

Kompilieren Sie den Code:

javac StringtoDouble.java

Führen Sie den kompilierten Code aus:

java StringtoDouble

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Wenn Sie die Zeilen, die versuchen, invalidDoubleString zu parsen, einkommentieren und den Code erneut ausführen, würden Sie die Fehlermeldung aus dem catch-Block sehen, was zeigt, wie das Programm ungültige Eingaben behandelt.

Dieser Schritt zeigt Ihnen, wie Sie String-Darstellungen von Zahlen in tatsächliche double-Werte umwandeln können, was eine entscheidende Fähigkeit für die Verarbeitung von Eingaben in Ihren Java-Programmen ist.

Unterscheidung zwischen Fließkommazahlen (double) und Ganzzahlen (int)

In diesem Schritt werden wir untersuchen, wie man in Java zwischen double- und int- (Ganzzahl-)Werten unterscheidet, insbesondere wenn es um Zahlen geht, die ähnlich aussehen können. Während double Zahlen mit Dezimalstellen und auch ganze Zahlen darstellen kann, kann int nur ganze Zahlen darstellen. Das Verständnis dieses Unterschieds ist entscheidend für die Wahl des richtigen Datentyps und die Durchführung genauer Berechnungen.

Erstellen Sie mit dem Dateiexplorer der WebIDE eine neue Java-Datei namens NumberTypes.java in Ihrem ~/project-Verzeichnis.

Öffnen Sie NumberTypes.java und fügen Sie folgenden Code hinzu:

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
    }
}

In diesem Code:

• Wir deklarieren eine int-Variable integerValue.
• Wir deklarieren zwei double-Variablen, eine, die eine ganze Zahl darstellt (doubleValueWhole), und eine mit einer Dezimalstelle (doubleValueDecimal).
• Wir geben diese Werte aus, um ihre Darstellung zu beobachten.
• Wir verwenden den instanceof-Operator mit den Wrapper-Klassen Integer und Double, um die Objekttypen explizit zu prüfen, ähnlich wie in der ersten Stufe.
• Wir zeigen auch einen Vergleich zwischen einem int und einem double. Java führt eine Typanpassung (type promotion) durch und wandelt das int in ein double um, bevor der Vergleich durchgeführt wird. Daher ergibt integerValue == doubleValueWhole true.

Speichern Sie die NumberTypes.java-Datei.

Jetzt kompilieren und führen wir das Programm aus. Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden.

Kompilieren Sie den Code:

javac NumberTypes.java

Führen Sie den kompilierten Code aus:

java NumberTypes

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe hilft, den Unterschied zwischen der Speicherung und Darstellung von int- und double-Werten zu veranschaulichen und zeigt, wie man instanceof mit ihren Wrapper-Klassen verwenden kann, um ihre Typen zu prüfen. Obwohl ein double einen ganzzahligen Wert enthalten kann, ist es grundsätzlich ein Fließkommatyp, der sich von einem Ganzzahltyp unterscheidet.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Zahl ein Double ist. Wir haben zunächst die Double-Wrapper-Klasse untersucht und den instanceof-Operator verwendet, um festzustellen, ob ein Objekt eine Instanz von Double ist. Wir haben bemerkt, dass instanceof mit Double-Objekten funktioniert, aber nicht direkt mit primitiven double-Typen.