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.2 Anweisungen formen Programme ### 2.2.1 Anweisungen Java zählt zu den imperativen Programmiersprachen, in denen der Programmierer die Abarbeitungsschritte seiner Algorithmen durch Anweisungen (engl. statements) vorgibt. Anweisungen können unter anderem sein: Ausdrucksanweisungen etwa für Zuweisungen oder Funktionsaufrufe Fallunterscheidungen (zum Beispiel mit if) Schleifen für Wiederholungen (etwa mit for oder do-while)
Hinweis Diese Befehlsform ist für Programmiersprachen gar nicht selbstverständlich, da es Sprachen gibt, die zu einer Problembeschreibung selbstständig eine Lösung finden. Ein Vertreter dieser Art Sprachen ist Prolog. Die Schwierigkeit hierbei liegt darin, die Aufgabe so präzise zu beschreiben, dass das System eine Lösung finden kann. Auch die Datenbanksprache SQL ist keine imperative Programmiersprache, denn wie das Datenbankmanagement-System zu unserer Anfrage die Ergebnisse ermittelt, müssen und können wir weder vorgeben noch sehen.
### 2.2.2 Eine Klasse bildet den Rahmen Programme setzen sich aus Anweisungen zusammen. In Java können jedoch nicht einfach Anweisungen in eine Datei geschrieben und dem Compiler übergeben werden. Sie müssen zunächst in einen Rahmen gepackt werden. Dieser Rahmen deklariert eine Klasse mit ihren Funktionen und Variablen. Die nächsten Programmcodezeilen werden am Anfang etwas befremdlich wirken (wir erklären die Elemente später genauer). Die folgende Datei erhält den (frei wählbaren) Namen Main.java. Listing 2.1 Main.java
    public class Main
    {
      public static void main( String[] args )
      {
        // Hier ist der Anfang unserer Programme
        // Jetzt ist hier Platz für unsere eigenen Anweisungen
        // Hier enden unsere Programme
      }
    }
Hinter den beiden Geteilt-Zeichen // befindet sich ein Kommentar. Er gilt bis zum Ende der Zeile und dient dazu, Erläuterungen zu den Quellcodezeilen hinzuzufügen, die den Code verständlicher machen. Eclipse zeigt Schlüsselwörter, Literale und Kommentare farbig an. Diese Farbgebung lässt sich unter Window • Preferences ändern. Java ist eine objektorientierte Programmiersprache, die Programmlogik außerhalb von Klassen nicht erlaubt. Aus diesem Grund deklariert die Datei Main.java mit dem Schlüsselwort class eine Klasse Main, um später eine Funktion mit der Programmlogik anzugeben. Der Klassenname darf grundsätzlich beliebig sein, doch besteht die Einschränkung, dass in einer mit public deklarierten Klasse der Klassenname so lauten muss wie der Dateiname. Alle Schlüsselwörter in Java beginnen mit Kleinbuchstaben und Klassennamen üblicherweise mit Großbuchstaben. In den geschweiften Klammern der Klasse folgen Deklarationen von Methoden, also Funktionen, die die Klasse anbietet. Eine Funktion ist eine Sammlung von Anweisungen unter einem Namen. Mathematische Funktionen sind mit Funktionen aus Programmiersprachen vergleichbar. Eine Sinus-Funktion schafft es beispielsweise, zu einem gegebenen Wert den Sinus zu berechnen. Der Begriff »Funktion« und der objektorientierte Name »Methode« werden in diesem Tutorial synonym verwendet. ### 2.2.3 Die Reise beginnt am main() Wir programmieren hier eine besondere Funktion, die sich main() nennt. Die Schlüsselwörter davor und die Angabe in dem Paar runder Klammern hinter dem Namen müssen wir einhalten. Die Funktion main() ist für die Laufzeitumgebung etwas ganz Besonderes, denn beim Aufruf des Java-Interpreters mit einem Klassennamen wird unsere Funktion als Erstes ausgeführt. [Na ja, so ganz präzise ist das auch nicht. In einem static-Block könnten wir auch einen Funktionsaufruf setzen, doch das wollen wir hier einmal nicht annehmen. static-Blöcke werden beim Laden der Klassen in die virtuelle Maschine ausgeführt. Andere Initialisierungen sind dann auch schon gemacht. ] Demnach werden genau die Anweisungen ausgeführt, die innerhalb der geschweiften Klammern stehen. Halten wir uns fälschlicherweise nicht an die Syntax für den Startpunkt, so kann der Interpreter die Ausführung nicht beginnen, und wir haben einen semantischen Fehler gemacht, obwohl die Funktion selbst korrekt gebildet ist. Innerhalb von main() befindet sich ein Parameter mit dem Namen args. Der Name ist willkürlich gewählt, wir werden allerdings immer args verwenden. Eclipse gibt im Falle eines Fehlers sehr viele Hinweise. Im folgenden Beispiel fehlt die schließende Klammer. Ein Fehler im Quellcode wird von Eclipse mit einer roten unterkringelten Linie angezeigt. Als weiterer Indikator wird (unter Umständen erst beim Speichern) ein kleines rundes Kreuz an der Fehlerzeile angezeigt. Gleichzeitig findet sich im Schieberegler ein kleiner roter Block. Im Packager Explorer findet sich ebenfalls ein Hinweis auf Fehler. Hier klicken, um das Bild zu vergrößern ### 2.2.4 Programme übersetzen und starten Der Quellcode eines Java-Programms lässt sich so allein nicht ausführen. Ein spezielles Programm, der Compiler (auch Übersetzer genannt), transformiert das geschriebene Programm in eine andere Repräsentation. Ein Quellcode mit Anweisungen für Programme muss aber nicht zwingend übersetzt werden. Eine Ablaufmodell ist der Interpreter. Er liest die Datei Schritt für Schritt ein und führt dann die Anweisungen aus. Der Compiler liest die Datei in einem Rutsch und meldet Fehler. Häufig werden Skriptsprachen interpretiert, früher waren es oft BASIC-Programme. Compiler für geläufige Programmiersprachen wie C(++) oder Delphi übersetzen den Quellcode in Maschinencode. Das ist Binärcode, der vom Prozessor im Computer direkt ausführbar ist. Da unterschiedliche Rechner aber unterschiedliche Prozessoren besitzen, sind die Programme nicht direkt auf verschiedenen Rechnerplattformen ausführbar. Java ist jedoch als Programmiersprache entworfen worden, die plattformunabhängig ist, sich also nicht an einen physikalischen Prozessor klammert. Der Compiler übersetzt den Quellcode nicht in Binärcode für einen konkreten Prozessor, sondern in einen plattformunabhängigen Code, den Bytecode. Prozessoren wie Intel-, AMD- oder G5-CPU können aber mit diesem Bytecode nichts anfangen. Hier hilft ein Interpreter weiter. Dieser liest Anweisung für Anweisung aus dem Bytecode und führt entsprechende Befehle auf dem Mikroprozessor aus. Daher ist Java eine compilierte und interpretierte Sprache zugleich. Eclipse besitzt keine Schaltfläche zum Übersetzen. Zum einen lässt Eclipse automatisch einen Compiler im Hintergrund laufen – sonst würden wir die Fehlermeldungen zur Tippzeit nicht sehen können – und zum anderen nimmt Eclipse das Speichern zum Anlass für einen Übersetzungsvorgang. ### 2.2.5 Funktionsaufrufe als Ausdrücke und Anweisungen In den vorangehenden kleinen Beispielen haben wir schon mit System.out.println() ein Beispiel für einen Funktionsaufruf gesehen. Allgemein hat ein Funktionsaufruf das Format:
    funktionsname()                       // Syntax eines Funktionsaufrufes
Funktionsaufrufe können als Ausdrücke eingesetzt werden, wenn sie mit einem Semikolon abgeschlossen werden.
    funktionsname();                      // Funktionsaufruf als Anweisung
Innerhalb der Klammern dürfen wir Argumente angeben, wenn die Funktion dies gestattet. Die println()-Funktion erlaubt zum Beispiel Strings als Argumente, die dann auf der Konsole erscheinen. ### 2.2.6 print(), println() und printf() für Bildschirmausgaben Mit der Funktion println() lassen sich Meldungen auf dem Bildschirm ausgeben. Die meisten Methoden verraten durch ihren Namen, was sie leisten, und für eigene Programme ist es sinnvoll, aussagekräftige Namen zu verwenden. Wenn die Java-Entwickler die Methode glubschi() genannt hätten, würde uns der Sinn der Methode verborgen bleiben. println() zeigt jedoch durch den Wortstamm »print« an, dass etwas geschrieben wird. Die Endung ln (kurz für line) bedeutet, dass noch ein Zeilenvorschubzeichen ausgegeben wird. Umgangssprachlich heißt das: Eine neue Ausgabe beginnt in der nächsten Zeile. Neben println() existiert die Bibliotheksfunktion print(), die keinen Zeilenvorschub anhängt. Implementieren [»Implementieren« stammt vom lateinischen Wort »implere« ab, was für »erfüllen« und »ergänzen« steht. ] wir eine vollständige Java-Klasse, die etwas auf dem Bildschirm ausgibt. Listing 2.2 Main.java
    class Main
    {
      public static void main( String[] args )
      {
        // Hier ist der Anfang unserer Programme

        System.out.println( "Hallo Javanesen" );
        System.out.println();                // Gibt nur eine Leerzeile aus

        // Hier enden unsere Programme
      }
    }
Die printXXX()-Methoden [Abkürzung für Methoden, die mit print beginnen, also print() und println(). ] können in Klammern unterschiedliche Argumente bekommen. Ein Argument ist ein Wert, den wir der Funktion beim Aufruf mitgeben. Auch wenn eine Funktion keine Argumente erwartet, muss beim Aufruf hinter dem Funktionsnamen ein Klammernpaar folgen. Dies ist konsequent, da wir so wissen, dass es ein Funktionsaufruf ist und nichts anderes. Andernfalls führt es zu Verwechslungen mit Variablen. Die printXXX()-Aufrufe in unserem Beispiel geben Zeichenketten aus – ein anderes Wort für Zeichenkette ist String. Ein String ist eine Folge von Buchstaben, Ziffern oder Sonderzeichen in doppelten Anführungszeichen. #### Ausdrucksanweisung Wird ein Ausdruck mit einem Semikolon zu einer Anweisung, so nennen wir das Ausdrucksanweisung (engl. expression statements). Neben Funktionsaufrufen gibt es andere Formen von Ausdrucksanweisungen, wie etwa Zuweisungen, doch allen ist gemeinsam, dass sie mit einem Semikolon abgeschlossen werden. [Das Semikolon dient auch nicht wie in Pascal zur Trennung von Anweisungen, sondern schließt sie immer ab. ]
Hinweis Nicht jeder Ausdruck kann eine Ausdrucksanweisung sein. So ist es nicht erlaubt, im Quellcode einfach 2*5; zu schreiben.
Es lassen sich auch Funktionen in dieser Form anwenden, die selbst ein Ausdruck sind und ein Ergebnis zurückgeben, beispielsweise eine Sinus-Funktion. Wird mit dem Ergebnis nichts gemacht, wird der Rückgabewert verworfen. Im Fall der Sinus-Funktion ist das nicht sinnvoll, denn sie macht außer der Berechnung nichts anderes.
    System.out.println( Math.sin(0.528740) ); // Funktionsaufruf sin() als Ausdruck
Etwas wackelig ist der Begriff Ausdrucksanweisung bei Funktionen, die keine Rückgabe liefern. println() ist so eine Funktion. Sie gibt nichts zurück (void) und ist daher auch kein Ausdruck. Daher führt Folgendes zu einem Compilerfehler:
    System.out.println( System.out.println() );
#### Überladene Methoden und variable Argumentlisten Eine weitere Eigenschaft von Java sind Methoden, die unterschiedliche Argumente (eine andere Anzahl oder einen unterschiedlichen Typ) besitzen, aber einen gleichen Namen tragen. Diese Funktionen nennen wir überladen. Die printXXX()-Methoden sind sogar vielfach überladen und akzeptieren neben dem Argumenttyp String auch Typen wie einzelne Zeichen, Wahrheitswerte oder Zahlen. Weiterhin unterstützt Java seit der Version 5 auch variable Argumentlisten, was bedeutet, dass es möglich ist, bestimmten ausgezeichneten Funktionen beliebig viele Argumente zu übergeben.
Beispiel Variable Argumentlisten am Beispiel von printf():
    System.out.printf( "Hallo %s%n", "Welt" );               // Hallo Welt
    System.out.printf( "%s ist %d Jahre alt%n", "Isy", 26 ); // Isy ist 26 Jahre alt
#### System.out und System.err Das Laufzeitsystem bietet uns zwei Ausgabekanäle, in die wir normale Ausgaben und Fehler leiten können. Der Vorteil ist, dass über diese Unterteilung die Fehler von der herkömmlichen Ausgabe getrennt werden können. Standardausgaben wandern in System.out, und Fehlerausgaben werden in System.err weitergeleitet. out und err sind vom gleichen Typ, sodass die println()- oder print()-Varianten bei beiden gleich bleiben.
    System.out.println( "Das ist eine normale Ausgabe" );
    System.err.println( "Das ist eine Fehlerausgabe" );
Hier klicken, um das Bild zu vergrößern Abbildung 2.2 Eclipse stellt normale Ausgaben schwarz und Fehlerausgaben rot dar. Damit ist leicht zu erkennen, welche Ausgabe in welchen Kanal geschickt wurde. #### Erste Idee der Objektorientierung In einer objektorientierten Programmiersprache sind alle Methoden an bestimmte Objekte gebunden (daher der Begriff objektorientiert). Betrachten wir zum Beispiel das Objekt Radio. Ein Radio spielt Musik ab, wenn der Einschalter betätigt wird und ein Sender und die Lautstärke eingestellt sind. Ein Radio bietet also bestimmte Dienste (Operationen) an, wie Musik an/aus, lauter/leiser. Zusätzlich hat ein Objekt auch noch einen Zustand: zum Beispiel die Lautstärke oder das Baujahr. Wichtig in objektorientierten Sprachen ist, dass die Operationen und Zustände immer (und da gibt es keine Ausnahmen) an Objekte beziehungsweise Klassen gebunden sind (mehr zu dieser Unterscheidung später). Der Aufruf einer Methode auf einem Objekt richtet die Anfrage genau an ein bestimmtes Objekt. Steht in einem Java-Programm nur die Anweisung lauter, so weiß der Compiler nicht, wen er fragen soll, wenn es etwa drei Radio-Objekte gibt. Was ist, wenn es auch einen Fernseher mit der gleichen Operation gibt? Aus diesem Grunde verbinden wir das Objekt, das etwas kann, mit der Operation. Ein Punkt trennt das Objekt von der Operation oder dem Zustand. So gehört auch println() zu einem Objekt, das die Bildschirmausgabe übernimmt. Dass eine Methode immer zu einem Objekt gehört, können wir auch an unserem eigenen Programm überprüfen. main() gehört zu der Klasse Main, die später ein Objekt bilden kann. Daher können wir in Java auch nicht einfach die Ausgabeanweisung schreiben. println() gehört zu einem Objekt mit dem Namen out. Dieses Objekt ist wiederum Teil der Klasse System. Wir können das zum Beispiel mit einem Aufruf von
    USA.president.ask( "Wenn alles 'Intelligent Design' ist, " +  "warum haben einige
    Menschen als Atavismus einen Stummelschwanz oder Halsfisteln?" );
vergleichen. Mehr zu diesen Aufrufen zu einem späteren Zeitpunkt. Das obige Beispiel macht aber jetzt schon deutlich, dass Strings mit dem Plus aneinander gehängt werden können. ### 2.2.7 Modifizierer Die Deklaration einer Klasse oder Methode kann einen oder mehrere Modifizierer (engl. modifier) enthalten, die zum Beispiel die Nutzung einschränken oder parallelen Zugriff synchronisieren.
Beispiel Im folgenden Programm kommen drei Modifier vor, die fett und unterstrichen sind:
    public class Main
    {
      public static void main( String[] args )
      {
        System.out.println( "Hallo Welt" );
      }
    }
Der Modifizierer public ist ein Sichtbarkeitsmodifizierer. Er bestimmt, ob die Klasse beziehungsweise die Funktion für andere sichtbar ist oder nicht. Der Modifizierer static zwingt den Programmierer nicht dazu, vor dem Methodenaufruf ein Objekt der Klasse zu bilden. Anders gesagt: Die Eigenschaft, ob sich eine Methode nur über ein konkretes Objekt aufrufen lässt oder eine Eigenschaft der Klasse ist, so dass für den Aufruf kein Objekt der Klasse nötig wird, bestimmt dieser Modifizierer. Wir werden in den ersten beiden Kapiteln nur mit statischen Funktionen arbeiten und ab Kapitel 3 nicht-statische Methoden einführen. ### 2.2.8 Anweisungen und Blöcke Atomare, also unteilbare Anweisungen, heißen auch elementare Anweisungen. Zu ihnen zählen zum Beispiel Funktionsaufrufe, Variablendeklarationen oder die leere Anweisung [Sie wird verwendet, wenn die Sprachgrammatik eine Anweisung vorschreibt, aber in dem Programmablauf keine Anweisung vorkommen muss. So muss etwa hinter dem Schleifenkopf eine Anweisung folgen. Wir werden bei den Schleifen ein Beispiel der leeren Anweisung sehen. ] , die nur aus einem Semikolon besteht. Programme bestehen in der Regel aus mehreren Anweisungen, die eine Anweisungssequenz ergeben. Die Laufzeitumgebung von Java führt jede einzelne Anweisung der Sequenz in der angegebenen Reihenfolge hintereinander aus. Ein Block fasst eine Gruppe von Anweisungen zusammen, die hintereinander ausgeführt werden. Anders gesagt: Ein Block ist eine Anweisung, die in den geschweiften Klammern { } eine Folge von Anweisungen zu einer neuen Anweisung zusammenfasst.
    {
      Anweisung1;
      Anweisung2;
      ...
    }
Ein Block kann überall dort verwendet werden, wo auch eine einzelne Anweisung stehen kann. Der neue Block hat jedoch eine Besonderheit für Variablen, da er einen lokalen Bereich für die darin befindlichen Anweisungen inklusive der Variablen bildet. #### Leerer Block und geschachtelte Blöcke Ein Block ohne Anweisung nennt sich leerer Block. Er verhält sich wie eine leere Anweisung, also wie ein Semikolon. Blöcke können auch geschachtelt werden, sodass Folgendes in der Funktion main() in Ordnung ist:
    public static void main( String[] args )
    {
      { System.out.println( "Hallo Computer" ); {{}}{{}{}}}
    }
### 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