2.5 Ausdrücke 

Beginnen wir mit mathematischen Ausdrücken, um dann die Schreibweise in Java zu ermitteln. Eine mathematische Formel, etwa der Ausdruck -27*9, besteht aus Operanden und Operatoren. Ein Operand ist eine Variable oder ein Literal. Im Fall einer Variablen wird der Wert der Variablen ausgelesen und danach die Berechnung gemacht.

int i = 12, j;
j = i * 2;

Die Multiplikation berechnet das Produkt von 12 und 2 und speichert das Ergebnis in j ab. Von allen primitiven Variablen, die in dem Ausdruck vorkommen, wird also der Wert ausgelesen und in den Ausdruck eingesetzt.¹  Dies nennt sich auch Wertoperation, da der Wert der Variablen betrachtet wird und nicht ihr Speicherort oder gar ihr Variablenname.

Die Arten von Operatoren

Operatoren verknüpfen die Operanden. Ist ein Operator auf genau einem Operand definiert, so nennt er sich unärer Operator (oder einstelliger Operator). Das Minus (negatives Vorzeichen) vor einem Operand ist ein unärer Operator, da er für genau den folgenden Operanden gilt. Die üblichen Operatoren Plus, Minus, Mal und Division sind binäre (zweistellige) Operatoren. Es gibt auch einen Fragezeichenoperator für bedingte Ausdrücke, der dreistellig ist.

Ausdrücke

Ein Ausdruck ist eine besondere Form der Anweisung, denn ein Ausdruck ergibt bei der Auswertung ein Ergebnis (auch Resultat genannt). Dieses ist oft ein

numerischer Typ (von arithmetischen Ausdrücken) oder ein

Referenztyp (von einer Objekt-Allokation).

Operatoren erlauben die Verbindung von einzelnen Ausdrücken zu neuen Ausdrücken. Einige Operatoren sind aus der Schule bekannt, wie Addition, Vergleich, Zuweisung und weitere. C(++)-Programmierer werden viele Freunde wiedererkennen.

2.5.1 Zuweisungsoperator und Verbundoperator 

Der Zuweisungsoperator kopiert den Wert eines Ausdrucks der rechten Seite in die Variable der linken Seite. In Java wird eine Zuweisung mit dem Gleichheitszeichen = dargestellt.

int a;
a = 12*3;

Da eine Zuweisung keine Anweisung, sondern ein Ausdruck mit einem Wert ist, der einen Rückgabewert ergibt, kann die Zuweisung auch an jeder anderen Stelle eingesetzt werden, an der ein Ausdruck stehen darf. Die Zuweisung kann auch in einem Funktionsaufruf erfolgen:

System.out.println( a = 19 );

Auch Zuweisungen der Form

a = b = 0;

sind erlaubt und gleichbedeutend mit b=0 und a=b beziehungsweise a=(b=0).

Daran lässt sich ablesen, dass beim Zuweisungsoperator die Auswertung von rechts nach links erfolgt.

boolean hatVorzeichen = (vorzeichen == '-');

Schön zu sehen an dem Beispiel ist die Auswertungsreihenfolge. Erst wird das Ergebnis des Vergleichs berechnet und dieser Wahrheitswert wird anschließend in hatVorzeichen kopiert.

Verbundoperatoren

In Java können Zuweisungen mit numerischen (und auch bitweisen, aber dazu später) Operatoren kombiniert werden. Für einen Operator # in dem Ausdruck a = a # (b) gilt die Abkürzung durch einen Verbundoperator a #= b. So addiert der Ausdruck a += 2 auf die Variable a 2 hinzu. Der Rückgabewert ist die um 2 erhöhte Variable a.

Falls es sich bei der rechten Seite um einen komplexeren Ausdruck handelt, wird dieser nur einmal ausgewertet. Dies ist wichtig bei Methodenaufrufen, die Seiteneffekte besitzen.

feld[2*i+j] = feld[2*i+j] + 1;

feld[2*i+j] += 1;

2.5.2 Präfix- oder Postfix-Inkrement und -Dekrement 

Erhöhen/Erniedrigen von Variablen ist eine sehr häufige Operation, wofür die Entwickler in der Vorgängersprache C auch einen Operator spendiert haben. Die praktischen Operatoren ++ und -- kürzen die Programmzeilen zum Inkrement und Dekrement ab.

i++;     // Abkürzung für i=i+1
j--;     //               j=j-1

Eine lokale Variable muss allerdings vorher initialisiert sein, da ein Lesezugriff vor einem Schreibzugriff stattfindet.

Vorher oder nachher

Die beiden Operatoren sind glücklicherweise Ausdrücke, sodass sie einen Wert liefern. Es macht jedoch einen feinen Unterschied, wo dieser Operator platziert wird. Es gibt ihn nämlich in zwei Varianten: vor der Variablen und dahinter. Steht das Inkrement vor der Variablen, sprechen wir von Prä-Inkrement/Prä-Dekrement, steht es dahinter von Post-Inkrement/Post-Dekrement; kurz auch Präfix/Postfix. Nutzen wir einen Präfix-Operator, so wird die Variable erst erhöht beziehungsweise erniedrigt und dann der Wert geliefert. Neben der Wertrückgabe gibt es eine Veränderung der Variablen.

int i = 10, j = 20;
System.out.println( ++i );       // 11
System.out.println( --j );       // 19
System.out.println( i );         // 11
System.out.println( j );         // 19

System.out.println( i++ );       // 10
System.out.println( j-- );       // 20
System.out.println( i );         // 11
System.out.println( j );         // 19

Das bedeutet, der Wert wird im Ausdruck verwendet und erst anschließend erhöht. Wir bekommen mit dem Präfix den Ausdruck nach der Operation und mit dem Postfix den Ausdruck davor.

Den Post-Inkrement finden wir auch im Namen der Programmiersprache C++. Es soll ausdrücken, dass es C-mit-eins-drauf ist, also ein verbessertes C. Mit dem Wissen über den Postfix-Operator ist klar, dass wir erst einen Zugriff haben und dann die Erhöhung stattfindet – also C++ ist auch nur C und der Vorteil kommt später. (Einer der Entwickler von Java, Bill Joy, hat einmal Java als C++-- beschrieben. Er meinte damit C++ ohne die schwer zu pflegenden Eigenschaften.)

Einige Besonderheiten

Wir wollen uns abschließend noch mit einer Kuriosität des Post-Inkrements und Prä-Inkrements beschäftigen, die nicht nachahmenswert ist:

a = 2;
a = ++a;      // a = 3

b = 2;
b = b++;      // b = 2

Im ersten Fall bekommen wir den Wert 3 und im zweiten Fall 2. Der erste Fall überrascht nicht. Denn a=++a erhöht den Wert 2 um 1 und anschließend wird 3 der Variablen a zugewiesen. Bei b ist es raffinierter. Der Wert von b ist 2 und dieser Wert wird intern vermerkt. Anschließend erhöht b++ die Variable b. Doch die Zuweisung setzt b auf den gemerkten Wert, der 2 war. Also ist b=2.

2.5.3 Unäres Minus und Plus 

Die binären Operatoren sitzen zwischen zwei Operanden, während sich ein unärer Operator genau einen Operanden vornimmt. Das unäre Minus (Operator zur Vorzeichenumkehr) etwa dreht das Vorzeichen des Operanden um. So wird aus einem positiven Wert ein negativer und aus einem negativen ein positiver. Das unäre Plus ist eigentlich unnötig; dies haben die Entwickler jedoch aus Symmetriegründen mit eingeführt.

Minus und Plus sitzen direkt vor dem Operator und der Compiler weiß selbstständig, ob dies unär oder binär ist. Er hat es leicht, wenn typische Ausdrücke wie

a = -2;

geschrieben werden.

int i = – - – 2 + – + 3;

2.5.4 Arithmetische Operatoren 

Ein arithmetischer Operator verknüpft die Operanden mit den Operatoren Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Zusätzlich gibt es einen Modulo-Operator (auch Restwertoperator genannt), der den bei der Division verbleibenden Rest betrachtet. Das Zeichen für den Modulo-Operator ist %. Er ist für ganzzahlige Werte sowie Fließkommazahlen definiert. Die arithmetischen Operatoren sind binär und auf der linken und rechten Seite sind die Typen numerisch. Der Ergebnistyp ist ebenfalls numerisch. Bei unterschiedlichen Datentypgrößen werden vor der Anwendung der Operation alle Operanden auf den größten vorkommenden gebracht. Anschließend wird die Operation ausgeführt und der Ergebnistyp entspricht dem umfassenderen Typ.

Der Divisionsoperator

Der binäre Operator »/« bildet den Quotienten aus Dividend und Divisor. Auf der linken Seite steht der Dividend und auf der rechten der Divisor. Die Division ist für Ganzzahlen und für Fließkommazahlen definiert. Bei der Ganzzahldivision wird zur Null hin gerundet. Schon in der Schulmathematik war die Division durch Null nicht definiert. Führen wir eine Ganzzahldivision mit dem Divisor 0 durch, so bestraft uns Java mit einer ArithmeticException. Bei Fließkommazahlen verläuft dies anders. Eine Division durch 0 liefert meistens bei +/- unendlich eine NaN; außer bei 0.0/0.0. Ein NaN steht für Not-A-Number und wird vom Prozessor erzeugt, falls er eine mathematische Operation wie die Division durch Null nicht durchführen kann.

Der Modulo-Operator %

Bei einer Ganzzahldivision kann es passieren, dass wir einen Rest bekommen. So geht die Division 9/2 nicht auf. Der Rest ist 1. In Java sowie in C(++) ist es der Modulo-Operator (engl. Remainder Operator), der uns diese Zahl liefert. Somit ist 9%2 gleich 1. Im Gegensatz zu C(++)²    erlaubt der Modulo-Operator in Java auch Fließkommazahlen und die Operanden können negativ sein. Die Sprachdefinition von C(++) schreibt bei der Division und beim Modulo mit negativen Zahlen keine Berechnungsmethode vor. In Java richtet sich die Division und der Modulo nach einer einfachen Formel: int(a/b)*b + (a%b) = a³ 

Aus dieser Gleichung folgt, dass beim Modulo das Ergebnis nur dann negativ ist, falls der Dividend negativ ist; er ist nur dann positiv, wenn der Dividend positiv ist. Es ist leicht einzusehen, dass das Ergebnis der Modulo-Operation immer echt kleiner ist als der Wert des Divisors. Wir haben den gleichen Fall wie bei der Ganzzahldivision, dass ein Divisor mit dem Wert 0 eine ArithmeticException auslöst.

class ModuloDivDemo
{
  public static void main( String args[] )
  {
    System.out.println( "5%3 = " + (5%3) );      // 2
    System.out.println( "5/3 = " + (5/3) );      // 1
    System.out.println( "5%-3 = " + (5%-3) );    // 2
    System.out.println( "5/-3 = " + (5/-3) );    // -1
    System.out.println( "-5%3 = " + (-5%3) );    // -2
    System.out.println( "-5/3 = " + (-5/3) );    // -1
    System.out.println( "-5%-3 = " + (-5%-3) );  // -2
    System.out.println( "-5/-3 = " + (-5/-3) );  // 1
  }
}

Modulo für Fließkommazahlen

Über die oben genannte Formel können wir auch bei Fließkommazahlen das Ergebnis einer Modulo-Operation leicht berechnen. Dabei muss beachtet werden, dass sich der Operator nicht so wie unter IEEE 754 verhält. Denn diese Norm schreibt vor, dass die Modulo-Operation den Rest von einer rundenden Division berechnet und nicht von einer abschneidenden Division. So wäre das Verhalten nicht analog zum Modulo bei Ganzzahlen. Java definiert das Modulo jedoch bei Fließkommazahlen genauso wie das Modulo auf Ganzzahlen. Wünschen wir ein Modulo-Verhalten wie es IEEE 754 vorschreibt, so können wir immer noch die Bibliotheksfunktion Math.IEEEremainder() verwenden.

Auch bei der Modulo-Operation bei Fließkommazahlen werden wir niemals eine Exception erwarten. Eventuelle Fehler werden, wie im IEEE-Standard beschrieben, mit NaN angegeben. Ein Überlauf oder Unterlauf kann zwar passieren, aber nicht geprüft werden.

5.0%3.0 = 2.0
5.0%-3.0 = 2.0
-5.0%3.0 = -2.0
-5.0%-3.0 = -2.0

Anwendung des Modulo-Operators

Im Folgenden wollen wir eine Anwendung des Modulo-Operators kennen lernen, denn dieser wird häufig dafür verwendet, eine einfache Überprüfung vorzunehmen. Bei einer eingegebenen Nummer wird dann einfach der Modulo-Wert zu einer fest vorgegebenen Zahl berechnet und ist dieser zum Beispiel 0, so ist die Nummer eine gültige Codenummer. Erstaunlicherweise gibt es Firmen, die tatsächlich nach diesem einfachen Kodierungsverfahren ihre Software schützen, vorne dabei ist Microsoft mit Windows 95 und Windows NT 4.0. Nachdem die Software installiert ist, wird der Benutzer aufgefordert, einen CD-Key einzugeben. Es werden von den älteren Softwarepaketen drei unterschiedliche Schlüssellängen verwendet.

Normale Version mit 10 Stellen: xxx-NNNNNNN Die ersten drei Stellen werden nicht geprüft. Die sieben letzten Ziffern müssen eine Quersumme ergeben, die durch 7 teilbar ist, also für die x % 7 = 0 gilt. So ist 1234567 eine gültige Zahl, da 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28 und 28 % 7 = 0 ist.

OEM Version: xxxxx-OEM-NNNNNNN-xxxxx Die ersten acht und die letzten fünf Stellen werden nicht geprüft. Die in der Mitte liegenden restlichen sieben Stellen werden nach dem gleichen Verfahren wie in der normalen Version geprüft.

Neuer CD-Schlüssel: xxxx-NNNNNNN Die ersten vier Ziffern steuern, ob es sich um eine Vollversion (0401) oder eine Update-Version (0502) handelt. Die restlichen sieben Ziffern sind wieder Modulo 7 zu nehmen.

Das Verfahren ist mehr als einfach. Die Hintergründe sollen natürlich nicht zum Installieren illegal erworbener Software führen. Dies verstößt selbstverständlich gegen das Urheberrecht! Diese Variante darf höchstens dann angewendet werden, wenn die Produkt-ID für die lizenzierte Software verloren ging!

Rundungsfehler

Prinzipiell sollten Anweisungen wie 1.1 – 0.1 immer 1.0 ergeben, doch interne Rundungsfehler bei der Darstellung treten auf und lassen das Ergebnis von Berechnung zu Berechnung immer ungenauer werden. Ein besonders ungünstiger Fehler trat 1994 beim Pentium Prozessor im Divisions-Algorithmus Radix-4 SRT auf, ohne dass der Programmierer der Schuldige war.

double x, y, z;

x = 4195835.0;
y = 3145727.0;
z = x – (x/y) * y;

System.out.println( z );

Ein fehlerhafter Prozessor liefert hier 256, obwohl laut Rechenregel das Ergebnis 0 sein muss. Laut Intel sollte für einen normalen Benutzer (Spieler, Softwareentwickler, Surfer?) der Fehler nur alle 27.000 Jahre auftauchen. Glück für die meisten. Eine Studie von IBM errechnet eine Fehlerhäufigkeit von einmal in 24 Tagen. Alles in allem hat Intel die CPUs zurückgenommen, über 400 Millionen US-Dollar verloren und spät den Kopf gerade noch aus der Schlinge gezogen.

Die meisten Rundungsfehler resultieren aber daher, dass endliche Dezimalbrüche im Rechner als Näherungswerte für periodische Binärbrüche repräsentiert werden müssen. 0,1 entspricht einer periodischen Mantisse im IEEE-Format.

2.5.5 Die relationalen Operatoren 

Relationale Operatoren vergleichen Ausdrücke miteinander und geben einen Wahrheitswert vom Typ boolean zurück. Ein anderes Wort für relationaler Operator ist Vergleichsoperator. Die von Java zur Verfügung gestellten Operatoren sind Größer (>), Kleiner (<), Test auf Gleichheit (==) und Ungleichheit (!=) sowie die Verbindung zu einem Größer-gleich (>=) beziehungsweise Kleiner-gleich (<=).

Ebenso wie arithmetische Operatoren passen die relationalen Operatoren ihre Operanden an einen gemeinsamen Typ an. Handelt es sich bei den Typen um Referenztypen, so sind nur die Vergleichsoperatoren == und != erlaubt.

Verwechslungsprobleme durch == und =

Die Verwendung des relationalen Operators == und der Zuweisung = führt bei Einsteigern oft zu Problemen, da die Mathematik für beide immer nur ein Gleichheitszeichen kennt. Glücklicherweise ist das Problem in Java nicht so drastisch wie beispielsweise in C(++), da die Typen der Operatoren unterschiedlich sind. Der Vergleichsoperator ergibt immer nur den Rückgabewert boolean. Zuweisungen von numerischen Typen ergeben jedoch wieder einen numerischen Typ. Es kann also kein Problem wie das folgende geben:

int a = 10, b = 11;
boolean result1 = ( a = b );        // Compilerfehler
boolean result2 = ( a == b );       // Das ist OK

2.5.6 Logische Operatoren 

Mit logischen Operatoren werden Wahrheitswerte nach definierten Mustern verknüpft. Logische Operatoren operieren nur auf boolean-Typen, andere Typen führen zu Compilerfehlern. Java bietet die Operatoren Und (&&), Oder (||), Xor (^) und Nicht (!) an. Xor ist eine Operation, die genau dann falsch zurückgibt, wenn entweder beide Operatoren wahr oder beide falsch sind. Sind sie unterschiedlich, so ist das Ergebnis wahr.

Kurzschlussoperatoren

Eine Besonderheit sind die Kurzschlussoperatoren (engl. Short-Circuit-Operator) && beziehungsweise || für Und und Oder. In der Regel wird ein logischer Ausdruck nur dann weiter ausgewertet, wenn er das Schlussergebnis noch beeinflussen kann. Sonst optimiert der Compiler die Programme zum Beispiel bei zwei Operanden:

Und: Ist einer der beiden Ausdrücke falsch, so kann der Ausdruck schon nicht mehr wahr werden. Das Ergebnis ist falsch.

Oder: Ist mindestens einer der Ausdrücke schon wahr, so ist auch der gesamte Ausdruck wahr.

Es ist aber in einigen Fällen gewünscht, dass alle Teilausdrücke ausgewertet werden, insbesondere wenn Funktionen Seiteneffekte bewirken. Daher führt Java zusätzliche Nicht-Kurzschlussoperatoren | und & ein, die in einem komplexen Ausdruck alle Teilausdrücke auswerten. Für das ausschließende Oder Xor (Operator ^) kann es keinen Kurzschlussoperator geben, da immer beide Operanden ausgewertet werden müssen, bevor das Ergebnis feststeht.

b = true || foo();   // foo() wird nicht aufgerufen.
b = false & foo();   // foo() wird aufgerufen.

2.5.7 Reihenfolge und Rang der Operatoren in der Auswertungsreihenfolge 

Aus der Schule ist der Spruch »Punktrechnung geht vor Strichrechnung« bekannt, sodass Ausdrücke der Art

1 + 2 * 3

zu 7 und nicht zu 9 ausgewertet werden. In den meisten Programmiersprachen gibt es eine Unzahl von Operatoren neben Plus und Mal, die alle ihre eigene Vorrangregeln besitzen. Der Multiplikationsoperator besitzt zum Beispiel eine höhere Vorrangregel (kurz Rang) und damit eine andere Auswertungsreihenfolge als der Plus-Operator.⁴ 

celsius = fahrenheit – 32 * 5 / 9;

Die erste Idee ist aber leider falsch, denn hier berechnet der Compiler 32*5/9. Das Ergebnis 17 wird von Fahrenheit abgezogen, was keine gültige Umrechnung ist. Richtig ist Folgendes:

celsius = ( fahrenheit – 32 ) * 5 / 9;

Die Rechenregeln für Mal vor Plus kann sich jeder noch leicht merken. Komplizierter ist die Auswertung bei den zahlreichen Operatoren, die seltener im Programm vorkommen.

boolean A = false,
        B = false,
        C = true;
System.out.println( A && B || C );

Gilt, dass entweder A && B oder C wahr sein müssen oder etwa A und B || C? Das Ergebnis fällt unterschiedlich aus. Entweder ist es true oder false.

Für dieserlei Feinheiten gibt es zwei Lösungen. Entweder in einer Tabelle mit Vorrangregeln nachschlagen oder auf diese Ungenauigkeiten verzichten.

Die Tabelle lehrt uns, dass im Beispiel A && B || C das Und stärker als das Oder bindet, also der Wert mit der Belegung A=false, B=false, C=true zu true ausgewertet wird. Vermutlich gibt es Programmierer, die dies wissen, oder eine Tabelle mit Rangordnungen immer am Monitor kleben haben. Aber beim Durchlesen von fremdem Code ist es nicht schön, immer wieder die Tabelle konsultieren zu müssen, die verrät, ob nun das binäre Xor oder das binäre Und stärker binden.

A / B / C

Die mathematische Assoziativität gilt bei Gleitkommazahlen natürlich nicht, da diese nicht ohne Rechenfehler ablaufen. Daher gilt eine Auswertung von links nach rechts.

2.5.8 Was C(++)-Programmierer vermissen könnten 

Da es in Java keine Pointer-Operationen gibt, existiert das Operatorzeichen zur Referenzierung (&) und Dereferenzierung (*) nicht. Ebenso ist ein sizeof unnötig, da das Laufzeitsystem und der Compiler immer die Größe von Klassen kennen beziehungsweise die primitiven Datentypen immer eine feste Länge haben. Eine abgeschwächte Version vom Kommaoperator ist in Java nur im Kopf von for-Schleifen erlaubt.

¹   Es gibt Programmiersprachen, da werden Wertoperationen besonders gekennzeichnet. So etwa in LOGO. Eine Wertoperation schreibt sich mit einem Doppelpunkt vor der Variablen. Etwa :X + :Y.

²   Wir müssten in C(++) die Funktion fmod() benutzen.

³   In C sind sie nur für Ganzzahlen definiert.

⁴   Es gibt Programmiersprachen, wie APL, die keine Vorrangsregeln kennen. Sie werten die Ausdrücke streng von rechts nach links oder umgekehrt aus.