double, int, boolean
byte, short, long, float, char
+ - * / % ++ -- += -= & && | || ˆ ! < > == <= >=
In der Mathematik kennt man natürliche, ganze, rationale, reelle und komplexe Zahlen. In Java korrespondieren mit diesen Variable sogenannter Grunddatentypen (auch primitive oder einfache Typen genannt), die ganzen (byte, short, int, long) und reellen (float, double) Zahlen entsprechen. Jede Variable eines solchen Datentyps beansprucht bei ihrer Allokation (Initialisierung) einen Speicherplatz fester Größe, die in Byte gemessen wird. Dadurch kann es nur endlich viele Zahlen des jeweiligen Typs geben.
So werden 4 Byte (32 Bit) für eine int-Zahl verwendet. Daher gibt es hiervon genau 232 Zahlen, nämlich die Zahlen -231 bis 231-1.
8 Byte werden für eine double-Zahl verwendet. Diese werden intern als Gleitpunkt-Dualzahlen dargestellt mit 11 Bit für den Exponenten, 1 Bit für das Vorzeichen und verbleibenden 52 Bit für die Mantisse. Es gibt insgesamt 264 double-Zahlen, die ungleichabständig auf dem Zahlenstrahl verteilt sind. In der Numerischen Mathematik lernen Sie das mit den double- und float-Zahlen verbundene Konzept der Gleitpunktzahlen und der damit verbundenen Rundungsfehler.
Nicht primitive Datentypen sind Zeichenketten, Felder und alle Klassen. Hierzu später mehr.
Schlüsselworte, Bezeichner, Blöcke, Kommentare, Anweisungen, Deklaration von Variablen, Wertzuweisungen
Arithmetische Operatoren
Wir beginnen mit einem Beispielprogramm, besser mit einer Beispielklasse (die Ziffern vor jeder Zeile dienen nur der Orientierung; sie gehören nicht zum Programm), das nichts anderes leistet als zwei Zahlen zu addieren.
1 public class Bsp1
2 {
3 public static void main ( String[] args )
4 {
5 double x, y, z;
6 x = 3.1675; y = -2.4567;
7 z = x + y;
8 System.out.println ( z );
9 } // Ende main()
10 } // Ende class
Die Java-spezifischen Schlüsselworte ("Terminalsymbole") sind alle fett hervorgehoben, die besonders wichtigen sind rot. In der folgenden Erläuterung sind die Termini, die die Grammatik erklären ("Nichtterminalsymbole"), grün.
Das Programm besteht aus einer einzigen Klasse (class) mit Bezeichner Bsp1: Es wird ausführbar durch die Methode main() in Programmzeile 3, die hier noch nicht erläutert wird. Man spricht auch von einer Applikationsklasse. Dieses Programm hat mit OOP nichts zu tun. Dennoch hilft es - wie auch die folgenden Beispiele -, mit den wichtigsten Sprachelementen vertraut zu machen. Später werden wir Klassen kennenlernen, von denen "Instanzen" in Form von Objekten gebildet werden.
Wiederholt werden soll eine
Warnung!!
Groß- und Kleinschreibung wird sehr wohl unterschieden. Bei Nichtbeachtung drohen kryptische Fehlermeldungen. Insbesondere muss der Namen der Datei, die das Quellprogramm einer Klasse (hier Bsp1) enthält, mit dem Bezeichner der Klasse übereinstimmen (also hier Bsp1.java heißen).
Zur Strukturierung der Klasse Bsp1 achte man auf (ineinandergeschachtelte) Blöcke , die durch geschweifte Klammern { und } eingeschlossen werden und Anweisungen enthalten. Der größte Block ist der, der die Klasse umfasst. Dann kommt der Teilblock zur Methode main. Kommentare (in einer Zeile) werden durch zwei Slashs (//) eingeleitet.
Die Zeile 5 enthält Deklarationen der Variablen mit Namen (Bezeichner) x, y und z vom Typ double. In Zeile 6 stehen zwei Wertzuweisungen, in Zeile 7 wird z ein Wert mit Hilfe eines arithmetischen Operators + (Addition) zugewiesen. Man kann das hier verwendete Gleichheitszeichen auch als Zuweisungsoperator bezeichnen, wobei links davon eine Variable und rechts davon ein Ausdruck steht. System.out.println() in Zeile 8 ist eine von Java gelieferte Methode, die das, was innerhalb der runden Klammern steht, auf den Bildschirm ausgibt. Später werden wir sehen, dass stets Zeichenketten (Schlüsselwort String) auf dem Bildschirm ausgegeben werden. Intern wird die double-Zahl in eine Zeichenkette umgewandelt.
Grundsätzlich muss jede Variable in einem Programm deklariert werden: ihr Name (Bezeichner) und ihr Typ werden hierdurch festgelegt. Die Deklaration kann auch direkt mit einer Wertzuweisung verbunden werden:
5 double x=3.1675, y=-2.4567, z=x+y;
ersetzt die alten Zeilen 5-7.
Jede Anweisung wird stets mit einem Semikolon ; abgeschlossen. Kommata dienen zur Auflistung wie in der eben modifizierten Zeile 5.
Weitere arithmetische Operatoren (Subtraktion, Multiplikation und Division) sind -, *, /.Der Potenzoperator wird in Java durch die Methode pow() der Klasse Math bereitgestellt:
z=Math.pow(x,y);
In Zeile 8 kann die Ausgabe benutzerfreundlicher gestaltet werden:
8 System.out.println("Ergebnis: z="+z);
Da die double-Zahl z intern in eine Zeichenkette umgewandelt wird, werden hier Zeichenketten "addiert" (verkettet), der Operator + ist also nicht nur ein arithmetischer Operator.
double-Zahlen können auch in der Gleitpunktform dargestellt werden: So ist double x=3.132 E-6; gleichwertig mit double x=0.000003132;. Es steht E-6 für 10 -6.
Mit double-Zahlen wird mit einer etwa 15-stelligen Genauigkeit gerechnet. Ist man aus Mangel an Speicherplatz mit einer geringeren Genauigkeit zufrieden, so kann man float-Zahlen verwenden.
In- und Dekrementoperatoren, Kurzoperatoren, arithmetische Operatoren
Durch den Datentyp int werden ganze Zahlen repräsentiert. Für eine int-Zahl werden 4 Byte zur Abspeicherung verwendet; durch sie werden alle ganzen Zahlen von -231 bis 231-1 dargestellt. Kommt man mit diesem Zahlenbereich nicht aus, kann man den Grunddatentyp long verwenden; kleinere Zahlenbereiche werden durch die Grunddatentypen short, byte erfasst.
Die arithmetischen Operatoren können selbstverständlich auch auf int-Zahlen angewendet werden. Aufpassen muss man nur bei der Division. So ergibt
int i=7, j=3, k=i/j;
den Wert k=2 (die größte ganze Zahl, die kleiner gleich dem Quotienten ist).
Warnung!!
In
int i=7, j=3; double x=i/j;
erhält x den Wert 2. Erst
int i=7, j=3; double x= (double) i/j;
leistet das Gewünschte. Man nennt das Vorschalten eines Datentyps in runden Klammern wie in (double) Casting, welches die Konvertierung eines Datentyps in einen anderen bewirkt.
Erwähnt werden sollte auch der binäre Modulo-Operator %, der durch k=i%j im Falle von int-Zahlen i, j, k den ganzzahligen Rest bei der Division von i durch j liefert.
Kurzoperatoren
Häufig will man eine ganze Zahl um eins
erhöhen oder erniedrigen (z.B. in Schleifen). Dies geschieht
durch die Kurzoperatoren ++,
--. So ergibt z.B.
int i=7, j=3;
i++; j--;
System.out.println("i="+i+" j="+j);
die Werte i=8 und j=2. Gleichwertig, aber ein wenig länger ist
int i=7, j=3;
i=i+1; j=j-1;
oder aber auch (durch Verwendung weiterer Kurzoperatoren +=, -= )
int i=7, j=3;
i += 1; j -= 1;
Die Kurzoperatoren ++, -- kann man einer Variablen voran- oder nachstellen. Der Unterschied wirkt sich nur aus, wenn man Ausdrücke der Form int a=i++ oder int b=++i verwendet. Näheres finden Sie in Lehrbüchern.
Vergleichsoperatoren (==, !=, <, >, <=, >=) und logische Operatoren (&, &&, |, ||, ^, !)
Boole'sche Variable sind logische Variable und haben nur die Werte (Literale) true, false. Boole'sche Ausdrücke entstehen meist durch Vergleich von Zahlen wie in
boolean w=(9==Math.pow(3,2));
Sie stehen stets in runden Klammern. Beachten Sie, dass zwei Gleichheitszeichen zum Vergleich zweier Zahlen verwendet werden, d.h. == ist ein (zweistelliger) Vergleichsoperator (relationaler Operator). Das Ergebnis sowohl der Vergleichs- als auch der logischen Operatoren ist stets vom Typ boolean. Während bei den Vergleichsoperatoren die Argumente Zahlen sind, sind es bei den logischen Operatoren ebenfalls logische Variable.
Der (einstellige) logische Operator ! verneint. Daher testet != auf Ungleichheit.
int x = 3;
boolean w = !((8< x) | (x != 1)); // bitweises ODER (ohne short curcuit)
ergibt für w den Wert false.
| 
