Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 2 Sprachbeschreibung
|  | 2.1 Elemente der Programmiersprache Java
|  |  | 2.1.1 Textkodierung durch Unicode-Zeichen
|  |  | 2.1.2 Literale
|  |  | 2.1.3 Bezeichner
|  |  | 2.1.4 Reservierte Schlüsselwörter
|  |  | 2.1.5 Token
|  |  | 2.1.6 Kommentare
|  | 2.2 Anweisungen formen Programme
|  |  | 2.2.1 Anweisungen
|  |  | 2.2.2 Eine Klasse bildet den Rahmen
|  |  | 2.2.3 Die Reise beginnt am main()
|  |  | 2.2.4 Programme übersetzen und starten
|  |  | 2.2.5 Funktionsaufrufe als Ausdrücke und Anweisungen
|  |  | 2.2.6 print(), println() und printf() für Bildschirmausgaben
|  |  | 2.2.7 Modifizierer
|  |  | 2.2.8 Anweisungen und Blöcke
|  | 2.3 Datentypen
|  |  | 2.3.1 Primitive Datentypen im Überblick
|  |  | 2.3.2 Wahrheitswerte
|  |  | 2.3.3 Variablendeklarationen
|  |  | 2.3.4 Ganzzahlige Datentypen
|  |  | 2.3.5 Die Fließkommazahlen float und double
|  |  | 2.3.6 Alphanumerische Zeichen
|  | 2.4 Ausdrücke, Operanden und Operatoren
|  |  | 2.4.1 Zuweisungsoperator
|  |  | 2.4.2 Arithmetische Operatoren
|  |  | 2.4.3 Unäres Minus und Plus
|  |  | 2.4.4 Zuweisung mit Operation
|  |  | 2.4.5 Präfix- oder Postfix-Inkrement und -Dekrement
|  |  | 2.4.6 Die relationalen Operatoren und die Gleichheitsoperatoren
|  |  | 2.4.7 Logische Operatoren Und, Oder, Xor, Nicht
|  |  | 2.4.8 Rang der Operatoren in der Auswertungsreihenfolge
|  |  | 2.4.9 Die Typanpassung (das Casting)
|  |  | 2.4.10 Überladenes Plus für Strings
|  |  | 2.4.11 Was C(++)-Programmierer vermissen könnten
|  | 2.5 Bedingte Anweisungen oder Fallunterscheidungen
|  |  | 2.5.1 Die if-Anweisung
|  |  | 2.5.2 Die Alternative mit einer if/else-Anweisung wählen
|  |  | 2.5.3 Die switch-Anweisung bietet die Alternative
|  | 2.6 Schleifen
|  |  | 2.6.1 Die while-Schleife
|  |  | 2.6.2 Schleifenbedingungen und Vergleiche mit ==
|  |  | 2.6.3 Die do-while-Schleife
|  |  | 2.6.4 Die for-Schleife
|  |  | 2.6.5 Ausbruch planen mit break und Wiedereinstieg mit continue
|  |  | 2.6.6 break und continue mit Sprungmarken
|  | 2.7 Methoden einer Klasse
|  |  | 2.7.1 Bestandteil einer Funktion
|  |  | 2.7.2 Beschreibungen in der Java-API
|  |  | 2.7.3 Aufruf einer Methode
|  |  | 2.7.4 Methoden ohne Parameter
|  |  | 2.7.5 Statische Funktionen (Klassenmethoden)
|  |  | 2.7.6 Parameter, Argument und Wertübergabe
|  |  | 2.7.7 Methoden vorzeitig mit return beenden
|  |  | 2.7.8 Nicht erreichbarer Quellcode bei Funktionen
|  |  | 2.7.9 Rückgabewerte
|  |  | 2.7.10 Methoden überladen
|  |  | 2.7.11 Vorgegebener Wert für nicht aufgeführte Argumente
|  |  | 2.7.12 Finale lokale Variablen
|  |  | 2.7.13 Rekursive Funktionen
|  |  | 2.7.14 Die Türme von Hanoi
|  | 2.8 Weitere Operatoren
|  |  | 2.8.1 Bits und Bytes
|  |  | 2.8.2 Operationen auf Bit-Ebene
|  |  | 2.8.3 Die Verschiebeoperatoren
|  |  | 2.8.4 Ein Bit setzen, löschen, umdrehen und testen
|  |  | 2.8.5 Bit-Funktionen der Integer- und Long-Klasse
|  |  | 2.8.6 Der Bedingungsoperator
|  | 2.9 Einfache Benutzereingaben
|  | 2.10 Zum Weiterlesen
## 2.3 Datentypen 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, dieser sich später nicht mehr ändern lässt und Java stark darauf achtet, welche Operationen erlaubt sind, zählt Java zu den streng typisierten Sprachen. [Im Gegensatz dazu steht Smalltalk. In Smalltalk ist zuerst einmal alles ein Objekt, und diese Objekte haben keinen Typ. Die Operationen werden erst zur Laufzeit an die Objekte gebunden. ] #### Primitiv- oder Verweis-Typ Die Datentypen in Java zerfallen in zwei Kategorien: primitive Typen und Referenztypen. Die einfachen Typen sind die eingebauten Datentypen, die nicht als Objekte verwaltet werden. Referenztypen gibt es in drei Ausführungen: Klassen-Typen, Schnittstellen-Typen (auch Interface-Typen genannt ) und Feld-Typen (auch Array-Typen genannt). 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 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.
Tabelle 2.4 Java-Datentypen und ihre Wertebereiche
Schlüsselwort/Typ | Länge in Byte | Belegung (Wertebereich)
boolean | 1 | true oder false
char | 2 | 16-Bit-Unicode-Zeichen (0x0000 ... 0xffff)
byte | 1 | –2^7 bis 2^7 – 1 (–128 ... 127)
short | 2 | –2^15 bis 2^15 – 1 (–32768 ... 32767)
int | 4 | –2^31 bis 2^31 – 1 (–2147483648 ... 2147483647)
long | 8 | –2^63 bis 2^63 – 1 (–9223372036854775808 ... 9223372036854775807)
float | 4 | 1,40239846E-45f ... 3,40282347E+38f
double | 8 | 4,94065645841246544E-324 ... 1,79769131486231570E+308
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 Zahlen-Literale; bei einer Zahl wie –1.2 oder –1 ist das Minus der unäre Operator und gehört nicht zur Zahl. Hier klicken, um das Bild zu vergrößern 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.
Hinweis Die Größe der Datentypen geben die Konstanten MAX_VALUE und MIN_VALUE bei den Klassen Byte, Integer, Long, Short, Character, Double und Float an. Listing 2.3 MinMaxValue.java, main()
    System.out.println( Byte.MIN_VALUE );       // –128
    System.out.println( Byte.MAX_VALUE );       // 127
    System.out.println( Character.MIN_VALUE );  // char '\u0000'
    System.out.println( Character.MAX_VALUE );  // char '\uFFFF'
    System.out.println( Double.MIN_VALUE );     // 4.9E-324
    System.out.println( Double.MAX_VALUE );     // 1.7976931348623157E308
### 2.3.2 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.3 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.
Beispiel Deklariere ein paar Variablen:
    int counter;                 // Zähler
    double income;               // Einkommen
    char c;                      // Für ein Zeichen
    boolean isDefined;           // Ist was definiert?
Eine Variablen-Deklaration kann in jeden Block geschrieben werden. 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 cdel 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 einer Zeichenkette keine Ziffer stehen darf. Auch darf der Bezeichnername mit keinem reservierten Schlüsselwort identisch sein. 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.
Beispiel Variablendeklaration mit Wertinitialisierung:
    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.
Beispiel Deklaration mehrerer Variablen auf einen Schlag. x und y bleiben uninitialisiert:
    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. #### Sichtbarkeit und Gültigkeitsbereich In jedem Block und auch in jeder Klasse [Die so genannten Objektvariablen oder Klassenvariablen, doch dazu später mehr. ] können Variablen deklariert werden. Jede Variable hat einen Geltungsbereich (engl. scope), auch Gültigkeitsbereich beziehungsweise Lebensdauer genannt. Sie ist nur in dem Block »lebendig«, in dem sie deklariert wurde. In dem Block ist die Variable lokal. Dazu ein Beispiel:
    public static void main( String[] args )
    {
      int i;
      {
        int j;                // j gilt nur in dem Block
        j = 1;
      }
    //  j = 2;                // j gibt es hier nicht mehr!
    }
    static void foo()
    {
      int i, k;               // i hat mit oberem i nichts zu tun
      {
    //    int k;              // Das würde nicht gehen!
      }
    }
Zu jeder Zeit können Blöcke aufgebaut werden. Außerhalb des Blocks sind deklarierte Variablen nicht sichtbar. Nach Abschluss des inneren Blocks, der j deklariert, ist ein Zugriff auf j nicht mehr möglich; auf i ist der Zugriff weiterhin erlaubt. Innerhalb eines Blocks können Variablennamen nicht genauso gewählt werden wie Namen lokaler Variablen eines äußeren Blocks oder wie die Namen für die Parameter einer Funktion. Das zeigt zum Beispiel die Deklaration der Variablen k. Obwohl andere Programmiersprachen das erlauben, haben sich die Java-Sprachentwickler dagegen entschieden, um Fehlerquellen zu vermeiden. #### Initialisierung von lokalen Variablen Die Laufzeitumgebung – beziehungsweise der Compiler – initialisiert lokale Variablen nicht automatisch mit einem Nullwert. Vor dem Lesen müssen sie von Hand initialisiert werden. [Anders ist das bei Objektvariablen (und statischen Variablen sowie Feldern). Sie sind standardmäßig mit null (Referenzen), 0 (bei Zahlen) oder false belegt. ]
    public static void main( String[] args )
    {
      int nene, williWurm;
      System.out.println( nene );     // Compilerfehler
      nene = 0;
      if ( nene == 1 )
        williWurm = 2;
      System.out.println( williWurm ); // Compilerfehler
    }
Die beiden lokalen Variablen nene und williWurm werden nicht automatisch mit null initialisiert, und so kommt es bei der versuchten Ausgabe von nene zu einem Compilerfehler, da ein Lesezugriff nötig ist, aber vorher noch kein Schreibzugriff stattfand. Erst die nächste Zeile mit nene = 0 ist in Ordnung. Weil Zuweisungen in bedingten Anweisungen nicht immer ausgeführt werden, meldet der Compiler auch einen Fehler, wenn er sich vorstellen kann, dass es einen Programmfluss ohne die Zuweisung gibt. Da williWurm nur nach der if-Abfrage auf den Wert 2 gesetzt wird, wäre nur unter der Bedingung nene gleich 1 ein Schreibzugriff auf williWurm erfolgt und ein folgender Lesezugriff möglich. Doch da der Compiler annimmt, dass es andere Fälle geben kann, wäre ein Zugriff auf eine nicht initialisierte Variable ein Fehler. Eclipse gibt einen Hinweis und Verbesserungsvorschlag, wenn eine lokale Variable nicht initialisiert ist. #### Gute Namen, schlechte Namen Zwei Variablen ähnlicher Schreibweise, etwa counter und counters, führen schnell zu Verwirrung. Auch 0 und O und 1 und l sind leicht zu verwechseln. Als Programmierer sollten wir uns konsistent an ein Namensschema halten. Auch sollten wir korrekt schreiben und auf Rechtschreibfehler achten, denn leicht wird aus necessaryConnection dann nesesarryConnection. Gültig – aber böse – ist auch:
    int ínt, ìnt, înt;
    boolean bôõleañ;
Auch Unicode-Sequenzen können vom Programmierer überall im Programm aufgenommen werden. Bei folgenden Deklarationen sind die Bezeichnernamen daher gleich:
    double übelkübel;
    double \u00FCbelk\u00FCbel;
Bemerkung In China gibt es 90 Millionen Familien mit dem Nachnamen Li. Das wäre so, als ob wir jede Variable var1, var2, ... nennen würden.
Die Kombination »rn« ist schwer zu lesen und je nach Zeichensatz leicht mit »m« zu verwechseln. Abstrakte Bezeichner sind zu vermeiden. Eine gemeine Idee ist auch folgende:
    boolean FALSE = true;
    boolean TRUE  = false;
Im Programmcode wird dann mit FALSE und TRUE gearbeitet. Einer der obersten Plätze bei den verpfuschtesten Java-Programmen ist uns gewiss ... 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. ### 2.3.4 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. ]
Beispiel Variablendeklaration für Ganzzahlen mit Wertinitialisierung:
    byte b = –12;
    int  i = 1243, j = 01230, k = 0xcafebabe;
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, wie das Beispiel an der Variablen i zeigt. Die Literale bestehen aus den Ziffern »0« bis »9«. Zusätzlich existieren die Oktal- und die Hexadezimalform, die die Zahlen zur Basis 8 und 16 schreiben. 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. 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.
Achtung Wer sich im kalifornischen Cupertino (unter anderem Apple-Hauptsitz) aufhält und dieses Buch liest, sollte es vermeiden, gut hörbar das Hexadezimalsystem rückwärts aufzuzählen. Das ist gesetzlich verboten!
Für Dualzahlen (also Binärzahlen zur Basis 2) gibt es keine Notation.
Achtung In Java-Programmen sollten Oktalzahlen mit Bedacht eingesetzt werden. Wer aus optischen Gründen mit der 0 eine Zahl linksbündig auffüllt, erlebt eine Überraschung.
    int i = 118;
    int j = 012;        // Oktal 012 ist dezimal 10
#### Der Datentyp long Ein Literal für Ganzzahlen doppelter Größe wird mit einem »l« oder »L« am Ende versehen.
Beispiel Deklaration eines long mit angehängtem »L«:
    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 zu Tage, 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« hinten angestellt werden:
    System.out.println( 123456789012345L );
Frage Was gibt die folgende Anweisung aus?
    System.out.println( 123456789 + 5432l );
### 2.3.5 Die Fließkommazahlen float und double Java unterscheidet mit den Datentypen float und double Fließkommazahlen einfacher und erhöhter Genauigkeit. 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. Zur Darstellung der Fließkomma-Literale gibt es zwei Notationen: Standard und wissenschaftlich. Egal ob die Standardnotation oder die wissenschaftliche verwenden Sie, die Literale bestehen aus einem Vorkommateil, einem Dezimalpunkt (kein Komma) und einem Nachkommateil. Ein Fließkomma-Literal muss keine Nachkommastellen besitzen, so dass auch Folgendes gültig ist:
    double d = 10.0 + 20. + 30;
#### Wissenschaftliche Notation bei Fließkommazahlen 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:
Standard | Wissenschaftlich
123450.0 | 1.2345E5
123450.0 | 1.2345E+5
0.000012345 | 1.2345E-5
#### 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.
Beispiel Gültige Zuweisungen für Fließkommazahlen vom Typ double und float:
    double pi = 3.1415, klein = .001, x = 3.00e+8;
    float   y = 3.00E+8F;
#### 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 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, was mit acht Byte einen Wertebereich von 922 337 203 685 477,5807 bis 922 337 203 685 477,5807 abdeckt. Erstaunlicherweise gab es einmal in C# den Datentyp currency für ganzzahlige Währungen. CMS ist Vorreiter der Initiative »Weg mit den Cent« – doch dieser »Weg« wurde verlassen. In C# gibt es den Datentyp decimal, der mit 14 Byte auch genügend Präzision bietet, um eine Zahl wie 0,0000000000000000000000000001 auszudrücken.
Frage Was ist das Ergebnis der Ausgabe?
    System.out.println( 20000000000f == 20000000000f+1 );
### 2.3.6 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).
Beispiel Korrekte Hochkommata für Zeichen und Zeichenketten:
    char   c = 'a';
    String s = "Heut' schon gebeckert?";
#### Escape-Sequenzen/Fluchtsymbole Für spezielle Zeichen 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) und kein '\x', was eine hexadezimale Zahl einleitet (dafür lässt sich in Java \uXXXX nutzen). ] zur Verfügung, die so nicht direkt als Zeichen dargestellt werden können.
Tabelle 2.5 Escape-Sequenzen
Zeichen | Bedeutung
\b | Rückschritt (Backspace)
\n | Zeilenschaltung (Newline)
\f | Seitenumbruch (Formfeed)
\r | Wagenrücklauf (Carriage return)
\t | Horizontaler Tabulator
\" | Doppeltes Anführungszeichen
\' | Einfaches Anführungszeichen
\\ | Backslash
Beispiel Zeichenvariablen mit Initialwerten und Sonderzeichen:
    char          a = 'a',
        singlequote = '\'',
            newline = '\n',
Die Fluchtsymbole sind für Zeichenketten die gleichen. Auch dort können bestimmte Zeichen mit Escape-Sequenzen dargestellt werden.
    String s        = "Er fragte: \"Wer lispelt wie Katja Burkard?\"";
    String filename = "C:\\Dokumente\\Siemens\\Schweigegeld.doc";
### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de