Wie man prüft, ob eine Zahl in Java durch eine andere Zahl teilbar ist

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob eine Zahl durch eine andere teilbar ist. Wir werden die Verwendung des Modulo-Operators (%) untersuchen, um die Teilbarkeit zu bestimmen, indem wir prüfen, ob der Rest einer Division null ist.

Sie üben die Verwendung des Modulo-Operators mit verschiedenen Zahlen und Divisoren und lernen auch, wie Sie den Sonderfall der Division durch Null behandeln, um Fehler in Ihren Java-Programmen zu vermeiden.

Verwenden des Modulo-Operators für die Teilbarkeitsprüfung

In diesem Schritt werden wir untersuchen, wie man den Modulo-Operator (%) in Java verwendet, um die Teilbarkeit zu prüfen. Der Modulo-Operator gibt den Rest einer Division zurück. Wenn der Rest einer Division 0 ist, bedeutet dies, dass die Zahl durch den Divisor ohne Rest teilbar ist.

Lassen Sie uns ein neues Java-Programm erstellen, um dies zu demonstrieren.

Öffnen Sie das Verzeichnis ~/project im Dateiexplorer auf der linken Seite.
Klicken Sie mit der rechten Maustaste in den leeren Bereich innerhalb des Verzeichnisses ~/project und wählen Sie "Neue Datei".
Benennen Sie die neue Datei DivisibilityCheck.java.
Öffnen Sie die Datei DivisibilityCheck.java im Code-Editor.
Kopieren und fügen Sie den folgenden Code in den Editor ein:
```
public class DivisibilityCheck {
    public static void main(String[] args) {
        int number = 10;
        int divisor = 2;

        // Use the modulo operator to check for divisibility
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 11;
        divisor = 3;

        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
    }
}
```
Schauen wir uns die neuen Teile an:
- int number = 10;: Dies deklariert eine Ganzzahlvariable namens number und weist ihr den Wert 10 zu.
- int divisor = 2;: Dies deklariert eine Ganzzahlvariable namens divisor und weist ihr den Wert 2 zu.
- number % divisor: Dies ist die Modulo-Operation. Sie berechnet den Rest, wenn number durch divisor geteilt wird.
- if (number % divisor == 0): Dies ist eine if-Anweisung. Sie prüft, ob das Ergebnis der Modulo-Operation gleich 0 ist. Wenn ja, wird der Code innerhalb des if-Blocks ausgeführt.
- else: Wenn die Bedingung in der if-Anweisung falsch ist (der Rest ist nicht 0), wird der Code innerhalb des else-Blocks ausgeführt.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, geben Sie cd ~/project ein und drücken Sie die Eingabetaste.
Kompilieren Sie das Java-Programm, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
javac DivisibilityCheck.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe. Eine Datei DivisibilityCheck.class wird im Verzeichnis ~/project erstellt.
Führen Sie das kompilierte Java-Programm aus, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
java DivisibilityCheck
```
Sie sollten die folgende Ausgabe sehen:
```
10 is divisible by 2
11 is not divisible by 3
```

Diese Ausgabe bestätigt, dass unser Programm den Modulo-Operator korrekt verwendet hat, um die Teilbarkeit zu prüfen.

Testen mit verschiedenen Divisoren

Im vorherigen Schritt haben wir die Teilbarkeit von 10 durch 2 und von 11 durch 3 geprüft. Jetzt ändern wir unser Programm, um es mit verschiedenen Zahlen und Divisoren zu testen und zu sehen, wie der Modulo-Operator verhält.

Öffnen Sie die Datei DivisibilityCheck.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

Fügen wir ein paar weitere Beispiele zur main-Methode hinzu. Fügen Sie die folgenden Codezeilen vor der schließenden geschweiften Klammer } der main-Methode ein:


        System.out.println("\nTesting with different numbers:");

        number = 15;
        divisor = 5;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 20;
        divisor = 7;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 100;
        divisor = 10;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

Wir haben drei neue Prüfungen mit verschiedenen Werten für number und divisor hinzugefügt. Die Zeile System.out.println("\nTesting with different numbers:"); fügt einfach eine Leerzeile und eine Überschrift hinzu, um die Ausgabe klarer zu gestalten.

Speichern Sie die geänderte Datei DivisibilityCheck.java (Strg+S oder Cmd+S).
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie das aktualisierte Java-Programm:
```
javac DivisibilityCheck.java
```
Wiederum wird keine Ausgabe angezeigt, wenn die Kompilierung erfolgreich ist.
Führen Sie das kompilierte Programm aus, um die Ergebnisse der neuen Testfälle zu sehen:
```
java DivisibilityCheck
```
Sie sollten jetzt die Ausgabe aus dem vorherigen Schritt sehen, gefolgt von der Ausgabe der neuen Testfälle:
```
10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10
```

Durch das Hinzufügen dieser Testfälle können Sie sehen, wie der Modulo-Operator korrekt erkennt, ob eine Zahl durch eine andere Zahl ohne Rest teilbar ist. Dies ist ein grundlegendes Konzept, das in vielen Programmieraufgaben verwendet wird, wie z. B. beim Prüfen auf gerade oder ungerade Zahlen oder beim Ausführen von Aktionen in regelmäßigen Abständen.

Behandlung der Division durch Null

In der Mathematik ist die Division durch Null undefiniert. Beim Programmieren führt der Versuch, durch Null zu teilen (oder eine Modulo-Operation mit Null als Divisor durchzuführen) normalerweise zu einem Fehler. Es ist wichtig, diese Situation in Ihrem Code zu behandeln, um zu verhindern, dass Ihr Programm abstürzt.

Ändern wir unser DivisibilityCheck.java-Programm, um eine Prüfung auf Division durch Null hinzuzufügen.

Öffnen Sie die Datei DivisibilityCheck.java im WebIDE-Editor.
Wir werden einen neuen Testfall hinzufügen, bei dem der Divisor 0 ist. Fügen Sie den folgenden Code vor der schließenden geschweiften Klammer } der main-Methode ein:
```
        System.out.println("\nTesting division by zero:");

        number = 10;
        divisor = 0;

        if (divisor == 0) {
            System.out.println("Error: Division by zero is not allowed.");
        } else if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
```
Hier ist, was wir hinzugefügt haben:
- if (divisor == 0): Dies ist eine neue if-Anweisung, die prüft, ob die Variable divisor gleich 0 ist.
- System.out.println("Error: Division by zero is not allowed.");: Wenn der Divisor 0 ist, gibt diese Zeile eine Fehlermeldung aus.
- else if (number % divisor == 0): Dies ist eine else if-Anweisung. Sie wird nur geprüft, wenn die erste if-Bedingung (divisor == 0) falsch ist. Hier wird die Modulo-Prüfung durchgeführt, aber nur wenn der Divisor nicht Null ist.
Speichern Sie die geänderte Datei DivisibilityCheck.java.
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie das aktualisierte Java-Programm:
```
javac DivisibilityCheck.java
```

Führen Sie das kompilierte Programm aus:

java DivisibilityCheck

Sie sollten die Ausgabe aus den vorherigen Schritten sehen, gefolgt von der Ausgabe für den Testfall der Division durch Null:

10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10

Testing division by zero:
Error: Division by zero is not allowed.

Durch das Hinzufügen der Prüfung if (divisor == 0) haben wir unser Programm robuster gemacht, indem wir einen potenziellen Fehler verhindern, wenn der Divisor Null ist. Dies ist ein wichtiger Aspekt beim Schreiben zuverlässigen Codes.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java überprüft, ob eine Zahl durch eine andere Zahl teilbar ist, indem man den Modulo-Operator (%) verwendet. Wir haben ein Java-Programm namens DivisibilityCheck.java erstellt und die if-Anweisung genutzt, um zu prüfen, ob der Rest der Division (number % divisor) gleich 0 ist. Wenn der Rest 0 ist, ist die Zahl durch den Divisor teilbar. Wir haben dies an Beispielen demonstriert, bei denen die Zahl teilbar ist und bei denen sie es nicht ist.