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 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort
Download: - ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / Java-Insel | vor >>
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel (8. Aufl.) 8., aktual. Auflage, geb., mit DVD 1.475 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1371-4 |
| 2 Sprachbeschreibung
|  | 2.1 Elemente der Programmiersprache Java
|  |  | 2.1.1 Token
|  |  | 2.1.2 Textkodierung durch Unicode-Zeichen
|  |  | 2.1.3 Literale
|  |  | 2.1.4 Bezeichner
|  |  | 2.1.5 Reservierte Schlüsselwörter
|  |  | 2.1.6 Kommentare
|  |  | 2.1.7 Die API-Dokumentation
|  | 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 Funktionsaufrufe als Anweisungen
|  |  | 2.2.5 print(), println() und printf() für Bildschirmausgaben
|  |  | 2.2.6 Ausdrucksanweisung
|  |  | 2.2.7 Erste Idee der Objektorientierung
|  |  | 2.2.8 Modifizierer
|  |  | 2.2.9 Anweisungen und Blöcke
|  | 2.3 Datentypen, Typisierung, Variablen und Zuweisungen
|  |  | 2.3.1 Primitive Datentypen im Überblick
|  |  | 2.3.2 Variablendeklarationen
|  |  | 2.3.3 Zuweisungsoperator
|  |  | 2.3.4 Variablendeklaration mit Wertinitialisierung
|  |  | 2.3.5 Wahrheitswerte
|  |  | 2.3.6 Ganzzahlige Datentypen
|  |  | 2.3.7 Die Fließkommazahlen float und double
|  |  | 2.3.8 Alphanumerische Zeichen
|  |  | 2.3.9 Gute Namen, schlechte Namen
|  | 2.4 Blöcke, Initialisierung und Sichtbarkeit
|  |  | 2.4.1 Blöcke und Anweisungen
|  |  | 2.4.2 Initialisierung von lokalen Variablen
|  |  | 2.4.3 Sichtbarkeit und Gültigkeitsbereich
|  | 2.5 Ausdrücke, Operanden und Operatoren
|  |  | 2.5.1 Arithmetische Operatoren
|  |  | 2.5.2 Unäres Minus und Plus
|  |  | 2.5.3 Zuweisung mit Operation
|  |  | 2.5.4 Präfix- oder Postfix-Inkrement und -Dekrement
|  |  | 2.5.5 Die relationalen Operatoren und die Gleichheitsoperatoren
|  |  | 2.5.6 Logische Operatoren Und, Oder, Xor, Nicht
|  |  | 2.5.7 Rang der Operatoren in der Auswertungsreihenfolge
|  |  | 2.5.8 Die Typanpassung (das Casting)
|  |  | 2.5.9 Überladenes Plus für Strings
|  | 2.6 Bedingte Anweisungen oder Fallunterscheidungen
|  |  | 2.6.1 Die if-Anweisung
|  |  | 2.6.2 Die Alternative mit einer if/else-Anweisung wählen
|  |  | 2.6.3 Die switch-Anweisung bietet die Alternative
|  | 2.7 Schleifen
|  |  | 2.7.1 Die while-Schleife
|  |  | 2.7.2 Die do-while-Schleife
|  |  | 2.7.3 Die for-Schleife
|  |  | 2.7.4 Schleifenbedingungen und Vergleiche mit ==
|  |  | 2.7.5 Ausbruch planen mit break und Wiedereinstieg mit continue
|  |  | 2.7.6 break und continue mit Sprungmarken
|  | 2.8 Methoden einer Klasse
|  |  | 2.8.1 Bestandteil einer Funktion
|  |  | 2.8.2 Signatur-Beschreibung in der Java-API
|  |  | 2.8.3 Aufruf einer Methode
|  |  | 2.8.4 Methoden ohne Parameter deklarieren
|  |  | 2.8.5 Statische Methoden (Klassenmethoden)
|  |  | 2.8.6 Parameter, Argument und Wertübergabe
|  |  | 2.8.7 Methoden vorzeitig mit return beenden
|  |  | 2.8.8 Nicht erreichbarer Quellcode bei Funktionen
|  |  | 2.8.9 Rückgabewerte
|  |  | 2.8.10 Methoden überladen
|  |  | 2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente
|  |  | 2.8.12 Finale lokale Variablen
|  |  | 2.8.13 Rekursive Methoden
|  | 2.9 Weitere Operatoren
|  |  | 2.9.1 Bits und Bytes
|  |  | 2.9.2 Operationen auf Bit-Ebene
|  |  | 2.9.3 Die Verschiebeoperatoren
|  |  | 2.9.4 Ein Bit setzen, löschen, umdrehen und testen
|  |  | 2.9.5 Bit-Funktionen der Integer- und Long-Klasse
|  |  | 2.9.6 Der Bedingungsoperator
|  |  | 2.9.7 Operator vermisst
|  | 2.10 Einfache Benutzereingaben
|  | 2.11 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 Abfrage 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 heißt Compilationseinheit (Compilation Unit) und deklariert eine Klasse mit ihren Methoden 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 Application.java. Listing 2.1 Application.java
    public class Application
    {
      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 Schrägstrichen // 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 Application.java mit dem Schlüsselwort class eine Klasse Application, 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 Unterprogrammen, die eine Klasse anbietet. Eine Methode ist eine Sammlung von Anweisungen unter einem Namen.
Hinweis Der Begriff »Methode« ist die korrekte Bezeichnung für ein Unterprogramm in Java – die Java Language Specification (JLS) verwendet den Begriff »Funktion« nicht. In diesem Tutorial verwende ich ab nun eine erweiterte Notation. »Funktion« bezeichnet ausdrücklich Unterprogramme, die mit einer Klasse verbunden sind und nicht mit einem Objekt. Die Unterscheidung ist an JavaScript [Aus §4.2 der ECMAScript Language Specification (http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf): »...a method is a function associated with an object via a property.«] angelehnt, doch viele JavaScript-Autoren nutzen diese mögliche Unterscheidung leider nicht. Die JLS trennt die beiden Methodentypen durch die Begriffe »class method« (wir sagen hier Klassenmethode oder statische Methode) beziehungsweise »instance method« (bei uns Objektmethode). Später in Kapitel 3, »Klassen und Objekte«, und Kapitel 6, »Eigene Klassen schreiben«, werden die beiden Konzepte detailliert vorgestellt.
### 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 gekringelten 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 Package Explorer findet sich ebenfalls ein Hinweis auf Fehler. Hier klicken, um das Bild zu vergrößern ### 2.2.4 Funktionsaufrufe als 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 Anweisungen 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.5 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, bliebe uns der Sinn der Methode verborgen. 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 Application.java
    class Application
    {
      public static void main( String[] args )
      {
        // Start of the program

        System.out.println( "Hallo Javanesen" );

        // End of the program
      }
    }
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. Der println()-Aufruf in unserem Beispiel gibt eine Zeichenkette aus – ein anderes Wort für Zeichenkette ist String. Ein String ist eine Folge von Buchstaben, Ziffern oder Sonderzeichen in doppelten Anführungszeichen. #### Überladene Methoden und variable Argumentlisten Java erlaubt Methoden, die gleich heißen, denen aber unterschiedliche Dinge übergeben werden können; diese Methoden nennen wir überladen.
Beispiel Die printXXX()-Methoden sind überladen und akzeptieren neben dem Argumenttyp String auch Typen wie einzelne Zeichen, Wahrheitswerte oder Zahlen.
    System.out.println( "Verhaften Sie die üblichen Verdächtigen!" );
    System.out.println( true );
    System.out.println( –273 );
    System.out.println( 1.6180339887498948 );
    System.out.println();                // Gibt eine Leerzeile aus
Java unterstützt seit der Version 5 variable Argumentlisten, was bedeutet, dass es möglich ist, bestimmten Funktionen beliebig viele Argumente zu übergeben.
Beispiel Die Methode printf() erlaubt variable Argumentlisten, um gemäß einer Formatierungsanweisung (im ersten Argument) die nachfolgenden Funktionsargumente aufzubereiten und auszugeben.
    System.out.printf("%d Kanäle und überall %s%n", 200, "Katzen");
    // 200 Kanäle und überall Katzen
### 2.2.6 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. In JavaScript ist im Quellcode einfach 3+4; erlaubt, in Java nicht.
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() );  // Compilerfehler!
### 2.2.7 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 out, das die Bildschirmausgabe übernimmt. Dieses Objekt ist wiederum Element der Klasse System. #### System.out und System.err Das Laufzeitsystem bietet uns zwei Ausgabekanäle: einen für normale Ausgaben und einen, in den wir 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 printXXX()-Methoden bei beiden gleich sind.
    System.out.println( "Das ist eine normale Ausgabe" );
    System.err.println( "Das ist eine Fehlerausgabe" );
Die Objektorientierung wird hierbei noch einmal besonders deutlich. Das out und das err Objekt sind zwei Objekte, die das Gleiche können, nämlich mit println() Ausgaben zu machen. Doch ist es nicht möglich, ohne explizite Objektangabe die Methode println() in den Raum zu rufen, und von der Laufzeitumgebung zu erwarten, dass diese weiß, ob die Anfrage an System.out oder an System.err gehen. Hier klicken, um das Bild zu vergrößern Abbildung 2.3 Eclipse stellt normale Ausgaben schwarz und Fehlerausgaben rot dar. Damit ist leicht zu erkennen, welche Ausgabe in welchen Kanal geschickt wurde. ### 2.2.8 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 Application
    {
      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, sodass für den Aufruf kein Objekt der Klasse nötig wird, bestimmt dieser Modifizierer. Wir arbeiten in den ersten beiden Kapiteln nur mit statischen Funktionen und werden ab Kapitel 3, »Klassen und Objekte«, nicht-statische Methoden einführen.
Hinweis Der Name des Modifizierers static kommt aus C(++). Dort hat static einen weiten Bereich an Anwendungen. Nun lässt sich darüber streiten, ob der Begriff für Java gut gewählt ist oder nicht, da er in Java lediglich »nur einmal pro Klasse« ausdrücken soll. Wir sollten also nicht versuchen, so sehr die Bedeutung »nur einmal« aus dem Wort »statisch« herauszulesen.
### 2.2.9 Anweisungen und Blöcke Funktionsaufrufe wie System.out.println(), 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, nennen sich atomare (auch elementare) Anweisungen. Diese unteilbaren Anweisungen werden zu Anweisungssequenzen zusammengesetzt, die Programme bilden. Die Laufzeitumgebung von Java führt jede einzelne Anweisung der Sequenz in der angegebenen Reihenfolge hintereinander aus. Anweisungen und -sequenzen dürfen nicht irgendwo stehen, sondern nur an bestimmen Stellen, etwa in einem Methodenkörper. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück | <top> | vor >>
Zum Katalog
Java ist auch eine Insel Jetzt bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Tipp
| Coding for Fun
Buchempfehlungen
| Objektorientierte Programmierung
| Einstieg in Eclipse 3.4
| Java 6 lernen mit Eclipse
| NetBeans Platform 6
| Java und XML
| Visual C# 2008
| IT-Handbuch für Fachinformatiker
| C++ von A bis Z
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2009
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