Operatoren in Java

Wie jede Programmiersprache kannt natürlich auch Java Operatoren. Wie sie funktionieren sollte zum "digitalen Allgemeinwissen" gehören. Hier will ich bloss eine einfache Übersicht, vorallem der Notation, auflisten.

Arithmetische Operatoren

In Java ganz Normal

Addition 9 + 4 = 13
Subtraktion 9 - 4 = 5
Multiplikation 9 * 4 = 36
Division 9 / 4 = 2.25
Teilerrest 9 % 4 = 1

Inkrementieren/Dekrementieren
int zahl=4; ++zahl; zahl ->Wert= 5 ; 5
int zahl=4; zahl++; zahl ->Wert= 4 ; 5
int zahl=4; --zahl; zahl ->Wert= 3 ; 3
int zahl=4; zahl--; zahl ->Wert= 4 ; 3

Seitenanfang

Operatoren für Vergleiche

In Java ganz Normal ausser der "Stolperfalle" 'Unwahr' sie wird '!=' und nicht '<>' dargestellt

Gleich -> 9 == 4 = FALSE
Ungleich -> 9 != 4 = TRUE
Grösser als -> 9 > 4 = TRUE
Kleiner als -> 9 < 4 = FALSE
Grösser oder Gleich als -> 9 >= 4 = TRUE
Kleiner oder Gleich als -> 9 <= 4 = FALSE

Seitenanfang

Boolische Operatoren

Werden meist in der IF Programmsteuerung verwendet. In Java werden Symbole verwendet (andere Sprachen haben z.B. NOT, AND, OR, XOR)
Negation (NOT)-> !TRUE = FALSE
'Und' (AND) alle Argumente sind wahr-> TRUE && TRUE && FALSE = FALSE
'Oder' (OR) mindestens ein Argument ist wahr -> TRUE || TRUE || FALSE = TRUE
Exklusiv oder (XOR), nur ein Argument ist wahr -> TRUE ^ TRUE ^ FALSE = FALSE

Seitenanfang

Operatoren für Bitmanipulation

Java kennt den Datentyp "byte" nicht wirklich. Der Wert 128 (0b10000000) kann zum Beispiel nicht zugeordnet werden (das erste Bit scheint immer ein Vorzeichen zu sein. Short, char (beide 2 Bytes gross) und was es sonst noch gibt, helfen da auch nicht weiter. Auch die Ausgabe kann nicht ohne Kunstgriffe sauber statt finden. Führende Nullen werden unterdrückt, dafür werden bei Werte über 127 oder unter 0 (schwer zuzuordnen) mit 32 Stellen angezeigt.
Da hat Sun sicher noch Handlungsbedarf ;-(. Somit rate ich; wenn man auf Bitebene (bzw. auf Bytes) zugreifen muss oder es mit Binärdateien zu tun hat, sich an anderen Sprachen zu bedienen (Beispiel C bzw C++)

byte B1 = 0b00101011 (entspricht der Zahl 43)
byte B2 = 0b00001111 (entspricht der Zahl 15)

Bits invertieren
----> B1 = 00101011
-> ~B1 = 11010100

Bits mit "AND" vergleichen (Bit wird gesetzt wenn BEIDE Bits an der selben Stelle gleich 1 sind).
----> B1 = 00101011
----> B2 = 00001111
B1&B2 = 00001011

Bits mit "OR" vergleichen (Bit wird gesetzt wenn EIN Bit an der selben Stelle gleich 1 sind).
----> B1 = 00101011
----> B2 = 00001111
B1|B2 = 00101111

Bits mit "XOR" vergleichen (Bit wird 0 wenn beide Bist an der selben Stelle gleich sind,).
----> B1 = 00101011
----> B2 = 00001111
B1^B2 = 00100100

Bits werden um die angegebenen Anzahl Stellen nach rechts verschoben.
----> B1 = 00101011
B1>>1 = 00010101

Bits werden um die angegebenen Anzahl Stellen nach rechts verschoben und mit 0 aufgefüllt.
----> B1 = 00101011
B1>>>1 = 00010101

Bits werden um die angegebenen Anzahl Stellen nach linka verschoben.
----> B1 = 00101011
B1<<1 = 01010110

Seitenanfang

Zuweisungs Operatoren

Natülich kann man auch mit Java den Variablen (je nach deklarierten Datentyp) Variablen einen Wert zuweisen. In Java gibt es auch Zuweisungsoperatoren, die gleich bei der Zuweisung den Wert bearbeiten

3 Variablen wurden deklariert mit dem Datentyp int, double, String
Einfache Zuweisung int = 6 ->Ausgabe: 6
->evtl. alter Wert wird überschrieben
Ergänzende Zuweisung int += 5 ->Ausgabe: 11
->alter Wert (6) wird um (5) erhöt. Weiteres -=
Dividierende Zuweisung int /= 5 ->Ausgabe: 2
->alter Wert (11) wird durch (5) geteilt. Integer "schluckt" die Nachkommastellen
Multiplizierende Zuweisung int *= 5 ->Ausgabe: 10
->alter Wert (2) wird mal (5) multipliziert.

Ich lasse bewusst alle logische (Bit) Zuweisungen weg, weil ich kaum glaube, dass jemand Java auf "Bitebene" benutzt.
Zuweisungen werden natürlich auch für den Klassen-Datentyp String benutzt:
Einfache Zuweisung String = "Hallo" ->Ausgabe: Hallo
->evtl. alter Wert wird überschrieben
Ergänzende Zuweisung String += " Welt" ->Ausgabe: Hallo Welt
->alter Wert (Hallo) wird mit ( Welt) ergänzt.

Bedingte Zuweisung (analog zu IF/ELSE) ist ebenfalls möglich und kann viel Programmcode ersparen
Variable= Bedingung ? Wert für die Variable, wenn Bedingung WAHR ist : Wert für die Variable, wenn Bedingung FALSCH ist

Weitere Regeln

Ausser der etwa ein Duzend Stufen zählende Verarbeitungsprioritäten (analog der arithmetischen Punkt- vor Strichregel) gibt es keine nenneswerte Regeln. Jedoch empfehle ich verkettete Operationen IMMER zu klammern. Das ist übersichtlicher, als immer die ganze Verarbeitungsprioritätentabelle zu berücksichtigen
ACHTUNG Falle:
= (Zuweisung) nicht mit == (Vergleich) verwechseln
Bei Operationen mit Operanden unterschiedlicher Genauigkeit, ist das Resultat immer die höhere Genauigkeit. int/float = float
Der Compiler ist recht kleinlich und lässt auch Absurditäten (die eigentlich den Regeln entsprechen) wie ein "o = ++i--;" nicht zu

Seitenanfang


Download des Sourcecode mit Beispiele



Datentypen



Quelle der nachbearbeiteten Tipps