Namensregeln, Einheiten-Verwaltung, Modulo/Divisionsrest-Operator

1. Namensregeln für Variable, Methoden und Klassen

Damit der Compiler Strukturelemente, Operatoren, Variable, Methoden, Klassen, Packages, etc. unterscheiden kann, gibt es Namensregeln, die eingehalten werden müssen.
Darüber hinaus gibt es Konventionen, die z.B. Plattformunabhängigkeit, Lesbarkeit, etc. unterstützen.

Für Indentifier (Bezeichner) gelten folgende grundsätzliche Regeln:

  • erstes Zeichen darf nur Buchstabe, '_' (Unterstrich) oder '$' (Dollar-Zeichen) sein

  • danach dürfen auch Ziffern folgen

  • Leerzeichen sind nicht erlaubt (wird für Trennung verwendet)

  • Groß-/Kleinschreibung wird unterschieden

  • Schlüsselwörter (Keywords) sind wichtige Hilfsmittel für den Compiler. Sie dürfen nicht für Identifier verwendet werden (z.B. void, int, float, double, boolean, byte, char, short, long, true, false, null, class, interface, package, import, private, protected, public, static, final, abstract, native, synchronized, volatile, transient, strictfp, throws, throw, try, catch, finally, if, else, for, while, do, switch, case, break, continue, return, new, this, super, extends, implements, enum, assert, instanceof, const, goto)

  • Nicht-ASCII-Unicode-Zeichen sind erlaubt (z.B. für Umlaute, Akzente, etc.), sind aber zum Erhalt der Plattform-Unabhängigkeit (Windows, Linux, MacOS, …​) zwingend zu vermeiden

  • Namen, die im JDK für besonders wichtige Klassen verwendet werden, sind technisch erlaubt, aber ebenfalls zwingend zu vermeiden: String, System, Double,LocalDate, …​

    in Arbeit ...

2. Einheitenverwaltung

In Java-Datentypen werden keine Einheiten verwaltet. Der Programmierer muss sich selbst um Umrechnungen etc. kümmern.

Es ist v.a. bei physikalischen Größen nötig, eine Einheit festzulegen. Der kluge Softwareentwickler notiert die gewählten Einheiten in Kommentaren, da Java (wie die meisten Programmiersprachen) kein Konzept für die Verwaltung von Einheiten vorsieht.

In Berechnungen muss der Programmierer u.U. nötige Umrechnungen selbst vornehmen.

Wenn Werte mit unterschiedlichem Einheiten verwaltet werden müssen (mm, m, km, …​), können für solche Werte Objekte mit extra Attribut für die Einheit und Umrechnungsmethoden implementiert werden.

3. Der Modulo/Divisionsrest-Operatur

In Java wird bei Division zweier Ganzzahl-Werte der Nachkomma-Teil einfach abgeschnitten: 13 / 5 → 2 Der "Rest" der Division kann mit einem eigenen Operator '%' (Modulo-Operator) berechnet werden: 13 % 5 → 3. Es gilt immer: Ergebnis der Ganzzahl-Division * Divisor (hier 5) + Rest = Dividend (hier 13) - also im verwendeten Beispiel: (13/5)*5 + 13%5 = 13.

Der Modulo-Operator wird auch "Restwert"- oder englisch "Remainder"-Operator genannt.

Sehr wertvoll ist seine Verwendung für mehrspaltige Ausgabe vieler Werte. Wenn man z.B. Zahlensammlungen 5-spaltig ausgeben will. kann man, sobald eine Zähl-Variable einen bestimmten Restwert (Modulo-Wert) hat, wird eine Zeilenschaltung ausgegeben:

    public void sameOrNextLine(int idx, float value) {
        if (idx > 0 && idx % 5 == 0) {
            System.out.println();
        }
        System.out.print(" \t" + value);
    }

    public void valuesTableManual() {
        System.out.println("==== valuesTableManual: ====");
        int i = 0;
        sameOrNextLine(i++, 17.5f);  // i++ erhöht 'i' NACH Nutzung um 1
        sameOrNextLine(i++, -2.3f);  // auf 2
        sameOrNextLine(i++, 3.1f);   // auf 3
        sameOrNextLine(i++, 5.4f);   // auf 4
        sameOrNextLine(i++, 7.7f);   // auf 5
        sameOrNextLine(i++, 8.3f);   // auf 6
        sameOrNextLine(i++, 9.2f);   // auf 7
        sameOrNextLine(i++, 10.0f);  // auf 8
        sameOrNextLine(i++, 9.8f);   // auf 9
        sameOrNextLine(i++, 11.1f);  // auf 10
        sameOrNextLine(i++, 10.2f);  // auf 11
        sameOrNextLine(i++, 9.9f);   // auf 12
        System.out.println("\n---- Es wurden " + i + " Werte verarbeitet ----");    }

Später werden wir diese wiederholte Operation in einer "Schleife" durchführen und die Werte aus einem "Array" entnehmen. Damit könnte der Code folgendermaßen aussehen:

    public void valuesTableLoopArr() {
        System.out.println("==== valuesTableLoopArr: ====");
        float[] vals = {17.5f, -2.3f, 3.1f,
                        5.4f, 7.7f, 8.3f,
                        9.2f, 10.0f, 9.8f,
                        11.1f, 10.2f, 9.9f};
        int i = 0;
        while (i < 12) {
            sameOrNextLine(i, vals[i]);
            i++;
        }
        System.out.println("\n---- Es wurden " + i + " Werte verarbeitet ----");
    }