2.3 Datentypen, Typisierung, Variablen und Zuweisungen

Java nutzt, wie es für imperative Programmiersprachen typisch ist, Variablen zum Ablegen von Daten. Eine Variable ist ein reservierter Speicherbereich und belegt – abhängig vom Inhalt – eine feste Anzahl von Bytes. Alle Variablen (und auch Ausdrücke) haben einen Typ, der zur Übersetzungszeit bekannt ist. Der Typ wird auch Datentyp genannt, da eine Variable einen Datenwert, auch Datum genannt, enthält. Beispiele für einfache Datentypen sind: Ganzzahlen, Fließkommazahlen, Wahrheitswerte und Zeichen. Der Typ bestimmt auch die zulässigen Operationen, denn Wahrheitswerte lassen sich nicht addieren, Ganzzahlen schon. Dagegen lassen sich Fließkommazahlen addieren, aber nicht Xor-verknüpfen. Da jede Variable einen vom Programmierer vorgegebenen festen Datentyp hat, der zur Übersetzungszeit bekannt ist und sich später nicht mehr ändern lässt, und Java stark darauf achtet, welche Operationen erlaubt sind, und auch von jedem Ausdruck spätestens zur Laufzeit den Typ kennt, ist Java eine statisch typisierte und streng (stark) typisierte Programmiersprache. [Während in der Literatur bei den Begriffen statisch getypt und dynamisch getypt mehr oder weniger Einigkeit herrscht, haben verschiedene Autoren unterschiedliche Vorstellungen der Begriffe streng (stark) typisiert und schwach typisiert.]

Primitiv- oder Verweis-Typ

Die Datentypen in Java zerfallen in zwei Kategorien:

• Primitive Typen. Die primitiven (einfachen) Typen sind die eingebauten Datentypen für Zahlen, Unicode-Zeichen und Wahrheitswerte.

• Referenztypen. Mit diesem Datentyp lassen sich Objektverweise etwa auf Zeichenketten, Dateien oder Datenstrukturen verwalten.

Warum Sun sich für diese Teilung entschieden hat, lässt sich mit zwei Gründen erklären:

• Zur Einführungszeit von Java kannten viele Programmierer die Syntax und Semantik von C(++) und ähnlichen imperativen Programmiersprachen. Zur neuen Sprache Java zu wechseln, fiel dadurch leichter, und es half, sich sofort auf der Insel zurechtzufinden. (Es gibt aber auch Programmiersprachen wie Smalltalk, die keine primitiven Datentypen besitzen.)

• Der andere Grund ist die Tatsache, dass häufig vorkommende elementare Rechenoperationen schnell durchgeführt werden müssen und bei einem einfachen Typ leicht Optimierungen durchzuführen sind.

Wir werden uns im Folgenden erst mit primitiven Datentypen beschäftigen. Referenzen werden nur dann eingesetzt, wenn Objekte ins Spiel kommen. Die nehmen wir uns in Kapitel 3, »Klassen und Objekte«, vor.

2.3.1 Primitive Datentypen im Überblick

In Java gibt es zwei Arten eingebauter Datentypen:

• arithmetische Typen (ganze Zahlen – auch integrale Typen genannt –, Gleitkommazahlen nach IEEE 754, Unicode-Zeichen)

• Wahrheitswerte für die Zustände wahr und falsch

Strings werden bevorzugt behandelt, sind aber lediglich Verweise auf Objekte. Die folgende Tabelle vermittelt dazu einen Überblick. Anschließend betrachten wir jeden Datentyp präziser.

Für float und double ist das Vorzeichen nicht angegeben, da die kleinsten und größten darstellbaren Zahlen sowohl positiv wie auch negativ sein können. Mit anderen Worten: Die Wertebereiche unterscheiden sich – anders als etwa bei int – nicht in Abhängigkeit vom Vorzeichen. Genau genommen gibt es in Java keine negativen Zahlenliterale; bei einer Zahl wie –1.2 oder –1 ist das Minus der unäre Operator und gehört nicht zur Zahl.

Zwei wesentliche Punkte zeichnen die primitiven Datentypen aus:

• Alle Datentypen haben eine festgesetzte Länge, die sich unter keinen Umständen ändert. Der Nachteil, dass sich bei einigen Hochsprachen die Länge eines Datentyps ändern kann, besteht in Java nicht. In den Sprachen C(++) bleibt dies immer unsicher, und die Umstellung auf 64-Bit-Maschinen bringt viele Probleme mit sich. Bei der Betrachtung der Auflistung fällt auf, dass char 16 Bit lang ist.

• Die numerischen Datentypen byte, short, int und long sind vorzeichenbehaftet, Fließkommazahlen sowieso. Dies ist leider nicht immer praktisch, aber wir müssen stets daran denken. Probleme gibt es, wenn wir einem Byte zum Beispiel den Wert 240 zuweisen wollen, denn der Wertebereich ist –128 bis 127. Ein char ist im Prinzip ein vorzeichenloser Ganzzahltyp.

Wenn wir also die numerischen Datentypen (lassen wir hier char außen vor) nach ihrer Größe sortieren wollten, könnten wir zwei Linien für Ganzzahlen und Fließkommazahlen aufbauen:

byte < short < int < long float < double

System.out.println( Byte.MIN_VALUE );       // –128 
System.out.println( Byte.MAX_VALUE );       // 127 
System.out.println( Character.MIN_VALUE );  // '\u0000' 
System.out.println( Character.MAX_VALUE );  // '\uFFFF' 
System.out.println( Double.MIN_VALUE );     // 4.9E-324 
System.out.println( Double.MAX_VALUE );     // 1.7976931348623157E308

In C# gibt es den Datentyp decimal, der mit 128 Bit (also 16 Byte) auch genügend Präzision bietet, um eine Zahl wie 0,000000000000000000000000001 auszudrücken.

2.3.2 Variablendeklarationen

Mit Variablen lassen sich Daten speichern, die vom Programm gelesen und geschrieben werden können. Um Variablen zu nutzen, müssen sie deklariert (definiert [In C(++) bedeuten Definition und Deklaration etwas Verschiedenes. In Java kennen wir diesen Unterschied nicht und betrachten daher beide Begriffe als gleichwertig. Die Spezifikation spricht nur von Deklarationen.] ) werden. Die Schreibweise einer Variablendeklaration ist immer die gleiche: Hinter dem Typnamen folgt der Name der Variablen. Sie ist eine Anweisung und wird daher mit einem Semikolon abgeschlossen. [Eine Software wie Mathematica warnt vor Variablen mit fast identischem Namen.] In Java kennt der Compiler von jeder Variablen und jedem Ausdruck genau den Typ.

int     age;                 // Alter 
double  income;              // Einkommen 
char    gender;              // Geschlecht (f oder m) 
boolean isPresident;         // Ist Präsident (true oder false) 
String  name;                // Name

Der Typname ist entweder ein einfacher Typ (wie int) oder ein Referenztyp. Viel schwieriger ist eine Deklaration nicht – kryptische Angaben wie in C gibt es in Java nicht. [Das ist natürlich eine Anspielung auf C, in dem Deklarationen wie char (*(*a[2])())[2] möglich sind. Gut, dass es mit cdecl ein Programm zum »Vorlesen« solcher Definitionen gibt.] Ein Variablenname (der dann Bezeichner ist) kann alle Buchstaben und Ziffern des Unicode-Zeichensatzes beinhalten, mit der Ausnahme, dass am Anfang des Bezeichners keine Ziffer stehen darf. Auch darf der Bezeichnername mit keinem reservierten Schlüsselwort identisch sein. Eine Variablendeklaration kann in fast jeden Block (etwa im Rumpf der Methode oder Rumpf der Klasse) geschrieben werden.

2.3.3 Zuweisungsoperator

In Java dient das Gleichheitszeichen = der Zuweisung (engl. assignment). [Die Zuweisungen sehen zwar so aus wie mathematische Gleichungen, doch existiert ein wichtiger Unterschied: Die Formel a = a + 1 ist – zumindest im Dezimalsystem ohne zusätzliche Algebra – mathematisch nicht zu erfüllen, da es kein a geben kann, das a = a + 1 erfüllt. Aus Programmiersicht ist es in Ordnung, da die Variable a um eins erhöht wird.] Der Zuweisungsoperator ist ein binärer Operator, bei dem auf der linken Seite die zu belegende Variable steht und auf der rechten Seite ein Ausdruck.

int a; 
a = 12 * 3;

Erst nach dem Auswerten des Ausdrucks kopiert der Zuweisungsoperator das Ergebnis in die Variable. Gibt es Laufzeitfehler, etwa durch eine Division durch null, gibt es keinen Schreibzugriff auf die Variable.

2.3.4 Variablendeklaration mit Wertinitialisierung

Den Variablen kann gleich bei der Deklaration ein Wert zugewiesen werden. Hinter einem Gleichheitszeichen steht der Wert, der oft ein Literal ist. Eine Zuweisung gilt nur für immer genau eine Variable.

int     age        = 33;        // Alter 
double  bodyHeight = 183;       // Körpergröße 
boolean vegetarian = true;      // Vegetarier?

Werden mehrere Variablen gleichen Typs bestimmt, so trennt sie ein Komma.

double x, y, 
       bodyHeight = 183;

Beispiel zur Variablendeklaration, -initialisierung und -ausgabe

Schreiben wir ein einfaches Programm, das zwei Variablen deklariert und zuweist. Die Variablenbelegung erscheint anschließend auf dem Bildschirm.

Listing 2.4 FirstVariable.java

public class FirstVariable 
{ 
  public static void main( String[] args ) 
  { 
    boolean hasVisitors; 
    hasVisitors = true; 
    int numberOfPersons = 102220; 
 
    System.out.print( "Sind Personen in der Disko? " ); 
    System.out.println( hasVisitors ); 
    System.out.println( "Wie viele? " + numberOfPersons ); 
  } 
}

Die Zeile hasVisitors = true ist eine Zuweisung – und somit ein Ausdruck, da sie einen Wert liefert –, die die Variable hasVisitors mit einem Wert initialisiert. Auch sie ist eine Anweisung und wird daher mit einem Semikolon abgeschlossen. Steht auf der rechten Seite keine Variable, so steht dort ein Literal, eine Konstante, wie in unserem Fall true, oder eine Verknüpfung mit einem Operator. Wir erwähnten bereits, dass es für Wahrheitswerte nur die Literale true und false gibt.

Das obige Beispiel macht ebenfalls deutlich, dass Strings mit dem Plus aneinandergehängt werden können; ist ein Teil kein String, so wird er in einen String konvertiert.

Zuweisungen sind auch Ausdrücke

Zwar finden sich Zuweisungen oft als Anweisungen wieder, doch können sie an jeder Stelle stehen, an der ein Ausdruck erlaubt ist, etwa in einem Funktionsaufruf wie print():

int a = 1;                          // Deklaration mit Initialisierung 
a = 2;                              // Anweisung mit Zuweisung 
System.out.println( a = 3 );        // Ausdruck mit Zuweisung. Liefert 3

Das Gleichheitszeichen dient in Java nur der Zuweisung; in anderen Programmiersprachen wird die Zuweisung durch ein anderes Symbol deutlich gemacht, etwa wie in Pascal mit :=. Um Zuweisungen von Vergleichen trennen zu können, definiert Java hier der C(++)-Tradition folgend einen binären Vergleichsoperator ==. Der Vergleichsoperator liefert den Ergebnistyp boolean.

System.out.println( a == 3 );       // Ausdruck mit Vergleich. Liefert true

Mehrere Zuweisungen in einem Schritt

Zuweisungen der Form a = b = c = 0; sind erlaubt und gleichbedeutend mit drei Anweisungen c = 0; b = c; a = b;. Die explizite Klammerung a = (b = (c = 0)) macht noch einmal deutlich, dass sich Zuweisungen schachteln lassen und Zuweisungen wie c = 0 Ausdrücke sind, die einen Wert liefern. Doch auch wenn wir meinen, dass

a = (b = c + d) + e;

eine coole Vereinfachung im Vergleich zu

b = c + d; 
a = b + e;

ist, sollten wir mit einer Zuweisung pro Zeile auskommen.

Die Reihenfolge der Auswertung zeigt anschaulich folgendes Beispiel:

int b = 10; 
System.out.println( (b = 20) * b );    // 400

2.3.5 Wahrheitswerte

Der Datentyp boolean beschreibt einen Wahrheitswert, der entweder true oder false ist. Die Zeichenketten true und false sind reservierte Wörter und bilden neben konstanten Strings und primitiven Datentypen so genannte Literale. Kein anderer Wert ist für Wahrheitswerte möglich, insbesondere werden numerische Werte nicht als Wahrheitswerte interpretiert.

Der boolesche Typ wird beispielsweise bei Bedingungen, Verzweigungen oder Schleifen benötigt.

2.3.6 Ganzzahlige Datentypen

Java stellt vier ganzzahlige Datentypen zur Verfügung: byte, short, int und long. Sie unterscheiden sich nur in der Länge, die jeweils 1, 2, 4 und 8 Byte umfasst. Die definierte Länge ist eine wesentliche Eigenschaft von Java. Ganzzahlige Typen (mit der Ausnahme von char) sind in Java immer vorzeichenbehaftet; einen Modifizierer unsigned wie in C(++) gibt es nicht. [In Java bilden long und short einen eigenen Datentyp. Sie dienen nicht wie in C(++) als Modifizierer. Eine Deklaration wie long int ist also falsch. Auf den iSeries-Servern von IBM – früher AS/400 – gibt es auch einen Datentyp unsigned long long int.] Negative Zahlen werden durch Voranstellen eines Minuszeichens gebildet. Ein Pluszeichen für positive Zeichen ist möglich.

Das hexadezimale und das oktale Zahlensystem

Die Literale für Ganzzahlen lassen sich in drei unterschiedlichen Zahlensystemen angeben. Das natürlichste ist das Dezimalsystem, bei dem die Literale aus den Ziffern »0« bis »9« bestehen. Zusätzlich existieren die Hexadezimal- und Oktalform, die die Zahlen zur Basis 16 und 8 schreiben.

• Ein hexadezimaler Wert beginnt mit »0x«. Da zehn Ziffern für 16 hexadezimale Zahlen nicht ausreichen, besteht eine Zahl zur Basis 16 zusätzlich aus den Buchstaben »a« bis »f« (beziehungsweise »A« bis »F«). Das Hexadezimalsystem heißt auch Sedezimalsystem.

• Ein oktaler Wert beginnt mit dem Präfix »0«. Mit der Basis 8 werden nur die Ziffern »0« bis »7« für oktale Werte benötigt. Der Name stammt aus dem lateinischen »octa«, was auf Deutsch »acht« heißt. Das Oktalsystem war früher eine verbreitete Darstellung, da nicht mehr einzelne Bits solo betrachtet werden mussten, sondern 3 Bits zu einer Gruppe zusammengefasst wurden. In der Kommunikationselektronik ist das Oktalsystem noch weiterhin beliebt.

Für Dualzahlen (also Binärzahlen zur Basis 2) gibt es keine Notation.

System.out.println( 1243 );         // 1243 
System.out.println( 01230 );        // 664 
System.out.println( 0xcafebabe );   // –889275714

int i = 118; 
int j = 012;                        // Oktal 012 ist dezimal 10

Der Datentyp long

Ein Literal für Ganzzahlen vom Typ long wird mit einem »l« oder »L« am Ende versehen.

long l = 123456789098L, m = –1L, n = 0xC0B0L;

Betrachten wir folgende Zeile, so ist auf den ersten Blick kein Fehler zu erkennen:

System.out.println( 123456789012345 );

Der Übersetzungsvorgang fördert zutage, dass der Compiler ein Ganzzahlliteral ohne explizite Größenangabe als 32 Bit langes int annimmt. Obige Zeile führt daher zu einem Compilerfehler, da die Zahl nicht im Wertebereich von –2147483648 bis 2147483647 liegt. Java reserviert also nicht so viele Bit wie benötigt und wählt nicht automatisch den passenden Wertebereich. (Allerdings ist das Compilerverhalten verwirrend, denn bei der Anweisung byte b = 12; »denkt« der Compiler ja auch nicht, dass 12 ein int ist.)

Dass eine Zahl long ist, muss ausdrücklich angegeben werden. Um die Zahl 123456789012345 gültig ausgeben zu lassen, müssen wir Folgendes schreiben:

System.out.println( 123456789012345l );

Ersichtlich wird, dass ein kleines »l« sehr viel Ähnlichkeit mit der Ziffer Eins besitzt. Daher sollte bei Längenangaben immer ein großes »L« hintenangestellt werden:

System.out.println( 123456789012345L );

System.out.println( 123456789 + 5432l );

2.3.7 Die Fließkommazahlen float und double

Für Fließkommazahlen einfacher und erhöhter Genauigkeit bietet Java die Datentypen float und double. Die Datentypen sind im IEEE-754-Standard beschrieben und haben eine Länge von 4 Byte für float und 8 Byte für double. Fließkommaliterale können einen Vorkommateil und einen Nachkommateil besitzen, die durch einen Dezimalpunkt (kein Komma) getrennt sind. Ein Fließkommaliteral muss keine Vor- oder Nachkommastellen besitzen, sodass auch Folgendes gültig ist:

double d = 10.0 + 20. + .11;

Standard Notation und wissenschaftliche Notation bei Fließkommazahlen

Zur Darstellung der Fließkommaliterale gibt es zwei Notationen: Standard und wissenschaftlich. Die wissenschaftliche Notation ist eine Erweiterung der Standardnotation. Es folgt hinter den Nachkommastellen ein »E« (oder »e«) mit einem Exponenten zur Basis 10. Der Exponent kann entweder positiv oder negativ [LOGO verwendet für negative Exponenten den Buchstaben N anstelle des E. In Java bleibt das E mit einem folgenden unären Plus- oder Minuszeichen.] sein, muss aber eine Ganzzahl sein. Die Tabelle stellt drei Beispiele zusammen:

Der Datentyp float

Standardmäßig sind die Literale vom Typ double. Ein nachgestelltes »f« (oder »F«) zeigt an, dass es sich um ein float handelt. Vorkommateil und Exponent dürfen durch die Vorzeichen »+« oder »–« eingeleitet werden.

double pi = 3.1415, delta = .001, x = 3.00e+8; 
float  y  = 3.00E+8F;

Auch für den Datentyp double lässt sich ein »d« (oder »D«) nachstellen, was allerdings nicht nötig ist, wenn Kommazahlen-Literale im Quellcode stehen; Zahlen wie 3.1415 sind automatisch vom Typ double. Während jedoch bei 1 + 2 + 3.0 erst 1 und 2 als int addiert, dann in double und anschließend auf 3.0 addiert werden, würde 1D + 2 + 3.0 gleich mit der Fließkommazahl 1 beginnen. So ist auch 1D gleich 1.0.

Noch genauere Auflösung bei Fließkommazahlen

Einen höher auflösenden beziehungsweise präziseren Datentyp für Gleitkommazahlen als double gibt es nicht. Sun bietet für diese Aufgabe im Paket java.math die Klasse BigDecimal an, die in Kapitel 5, »Mathematisches«, näher beschrieben ist. Das ist sinnvoll für Daten, die eine sehr gute Genauigkeit aufweisen sollen, wie zum Beispiel Währungen.

Einige Programmiersprachen besitzen für Währungen eingebaute Datentypen, wie LotusScript mit Currency, das mit acht Byte einen sehr großen und genauen Wertebereich abdeckt. (Erstaunlicherweise gab es einmal in C# den Datentyp currency für ganzzahlige Währungen.)

System.out.println( 20000000000F == 20000000000F+1 ); 
System.out.println( 20000000000D == 20000000000D+1 );

2.3.8 Alphanumerische Zeichen

Der alphanumerische Datentyp char (von engl. character, Zeichen) ist 2 Byte groß und nimmt ein Unicode-Zeichen auf. Ein char ist nicht vorzeichenbehaftet. Die Literale für Zeichen werden in einfache Hochkommata gesetzt. Spracheinsteiger verwechseln häufig die einfachen Hochkommata mit den Anführungszeichen der Zeichenketten (Strings). Die einfache Merkregel: ein Zeichen – ein Hochkomma, mehrere Zeichen – zwei Hochkommata (Gänsefüßchen).

char   c = 'a'; 
String s = "Heut' schon gebeckert?";

Da der Compiler ein char automatisch in ein int konvertierten kann, ist auch gültig int c = 'a';.

Escape-Sequenzen/Fluchtsymbole

Um spezielle Zeichen, etwa den Zeilenumbruch oder Tabulator, in einen String oder char setzen zu können, stehen Escape-Sequenzen [Nicht alle aus C stammenden Escape-Sequenzen finden sich auch in Java wieder. Es gibt kein '\a' (Alert), '\v' (vertikaler Tabulator), '\?' (Fragezeichen).] zur Verfügung.

char theLetterA  = 'a', 
     singlequote = '\'', 
     newline     = '\n',

String s        = "Er fragte: \"Wer lispelt wie Katja Burkard?\""; 
String filename = "C:\\Dokumente\\Siemens\\Schweigegeld.doc";

2.3.9 Gute Namen, schlechte Namen

Für die optimale Lesbarkeit und Verständlichkeit eines Programmcodes sollten Entwickler beim Schreiben einige Punkte berücksichtigen:

• Ein konsistentes Namensschema ist wichtig. Heißt ein Zähler no, nr, cnr oder counter? Auch sollten wir korrekt schreiben und auf Rechtschreibfehler achten, denn leicht wird aus necessaryConnection dann nesesarryConnection. Variablen ähnlicher Schreibweise, etwa counter und counters, sind zu vermeiden.

• Abstrakte Bezeichner sind zu vermeiden. Die Deklaration int TEN = 10; ist absurd. Eine unsinnige Idee ist auch die folgende: boolean FALSE = true, TRUE = false;. Im Programmcode würde dann mit FALSE und TRUE gearbeitet. Einer der obersten Plätze bei den verpfuschtesten Java-Programmen wäre uns gewiss ...

• Unicode-Sequenzen können zwar in Bezeichnern aufgenommen werden, doch sollten sie vermieden werden. In double übelkübel, \u00FCbelk\u00FCbel; sind beide Bezeichnernamen gleich, und der Compiler meldet einen Fehler.

• 0 und O und 1 und l sind leicht zu verwechseln. Die Kombination »rn« ist schwer zu lesen und je nach Zeichensatz leicht mit »m« zu verwechseln. Gültig – aber böse – ist auch: int ínt, ìnt, înt; boolean bôõleañ;

Ist ein Bezeichnername unglücklich gewählt (pneumonoultramicroscopicsilicovolcanoconiosis ist schon etwas lang), so lässt er sich problemlos konsistent umbenennen. Dazu wählen wir im Menü Refactor • Rename – oder auch kurz + + ; der Cursor muss auf dem Bezeichner stehen. Eine optionale Vorschau (engl. preview) zeigt an, welche Änderungen die Umbenennung nach sich ziehen wird. Neben Rename gibt es auch noch eine andere Möglichkeit. Dazu lässt sich auf der Variablen mit + ein Popup-Fenster mit Local Rename öffnen. Der Bezeichner wird selektiert und lässt sich ändern. Gleichzeitig ändern sich alle Bezüge auf die Variable mit.

Ihr Kommentar