Java Academy · Lektion

Runden und Grenzen mit Math

floor, ceil, round, min, max

Runden und Grenzen mit Math ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Runden und begrenzen

In dieser Lektion geht es um die Rundungsmethoden von Math (floor, ceil, round) sowie darum, Werte mit min und max zu begrenzen.

Math.floor

Math.floor rundet ab auf den nächstgelegenen ganzzahligen Wert und gibt einen double zurück. Math.floor(2.9) ergibt 2.0.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.floor(2.9));
        System.out.println(Math.floor(-2.1));
    }
}

Math.ceil

Math.ceil rundet auf. Math.ceil(2.1) ergibt 3.0, und Math.ceil(-2.9) ergibt -2.0.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.ceil(2.1));
        System.out.println(Math.ceil(-2.9));
    }
}

Math.round

Math.round rundet auf die nächste ganze Zahl; bei genauem Gleichstand (.5) wird aufgerundet. Bei einem double-Argument gibt die Methode einen long zurück.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.round(2.4));
        System.out.println(Math.round(2.5));
        System.out.println(Math.round(-2.5));
    }
}

Überraschungen beim Runden negativer Zahlen

Bei negativen Zahlen geht floor zu einem noch kleineren Wert und ceil in Richtung null. Math.round(-2.5) ergibt -2, weil bei genauem Gleichstand aufgerundet wird, also in Richtung positiver Unendlichkeit.

Kürzen durch Casten

Beim Casten eines double in einen int wird einfach der Nachkommateil entfernt, also in Richtung null gekürzt. Das unterscheidet sich bei negativen Zahlen von floor.

public class Main {
    public static void main(String[] args) {
        System.out.println((int) 2.9);
        System.out.println((int) -2.9);
        System.out.println((int) Math.floor(-2.9));
    }
}

Min und Max als Grenzen

Kombinieren Sie Math.max und Math.min, um einen Wert auf einen Bereich zu begrenzen. Math.max(0, Math.min(100, v)) hält v zwischen 0 und 100.

public class Main {
    public static void main(String[] args) {
        int v = 130;
        int clamped = Math.max(0, Math.min(100, v));
        System.out.println(clamped);
    }
}

Math.clamp

Modernes Java bietet Math.clamp(value, min, max), das die Begrenzung direkt vornimmt und leichter zu lesen ist als verschachtelte Aufrufe von min und max.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.clamp(130, 0, 100));
        System.out.println(Math.clamp(-5, 0, 100));
        System.out.println(Math.clamp(50, 0, 100));
    }
}

floorDiv und floorMod

Bei der Ganzzahldivision wird in Richtung null abgeschnitten, was bei negativen Zahlen überraschend sein kann. Math.floorDiv und Math.floorMod runden in Richtung negativer Unendlichkeit und liefern dadurch konsistente Ergebnisse.

public class Main {
    public static void main(String[] args) {
        System.out.println(-7 / 2);
        System.out.println(Math.floorDiv(-7, 2));
        System.out.println(Math.floorMod(-7, 2));
    }
}

Auf Dezimalstellen runden

Um auf N Dezimalstellen zu runden, skalieren Sie zunächst nach oben, runden und skalieren anschließend wieder nach unten: Runden Sie x mit Math.round(x * 100.0) / 100.0 auf zwei Dezimalstellen.

public class Main {
    public static void main(String[] args) {
        double price = 3.14159;
        double rounded = Math.round(price * 100.0) / 100.0;
        System.out.println(rounded);
    }
}

Die passende Rundungsmethode wählen

Verwenden Sie floor, um immer abzurunden, ceil, um immer aufzurunden, round für die nächste ganze Zahl und einen Cast zum Abschneiden. Für Begrenzungen bevorzugen Sie Math.clamp.

Schnelltest

Testen Sie Ihr Verständnis des Rundens.

Zusammenfassung

Sie haben das Runden und Begrenzen von Werten kennengelernt.

floor rundet ab, ceil rundet auf und round rundet auf die nächste ganze Zahl (bei Gleichstand nach oben).
Ein Cast schneidet in Richtung null ab.
Math.clamp (oder verschachtelte Aufrufe von min und max) begrenzt einen Wert auf einen Bereich.
floorDiv und floorMod behandeln negative Zahlen konsistent.

Häufig gestellte Fragen

Ist die Lektion „Runden und Grenzen mit Math“ kostenlos?

Ja — der vollständige Text von „Runden und Grenzen mit Math“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Runden und Grenzen mit Math“?

floor, ceil, round, min, max Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Runden und Grenzen mit Math“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy