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
Wenn ich eine Oper hundertmal dirigiert habe, dann ist es Zeit, sie wieder zu lernen. – Arturo Toscanini (1867 – 1957) # 2 Sprachbeschreibung Ein Programm in Java wird nicht umgangssprachlich beschrieben, sondern ein Regelwerk und eine Grammatik definieren die Syntax und die Semantik. In den nächsten Abschnitten werden wir kleinere Beispiele für Java-Programme kennenlernen, und dann ist der Weg frei für größere Programme. ## 2.1 Elemente der Programmiersprache Java Wir wollen im Folgenden über das Regelwerk, die Grammatik und Syntax der Programmiersprache Java sprechen und uns unter anderem über die Unicode-Kodierung, Token sowie Bezeichner Gedanken machen. Bei der Benennung einer Funktion zum Beispiel dürfen wir aus einer großen Anzahl Zeichen wählen; der Zeichenvorrat nennt sich Lexikalik. Die Syntax eines Java-Programms definiert die Token und bildet so das Vokabular. Richtig geschriebene Programme müssen aber dennoch nicht korrekt sein. Unter dem Begriff »Semantik« fassen wir daher die Bedeutung eines syntaktisch korrekten Programms zusammen. Die Semantik bestimmt, was das Programm macht. Die Abstraktionsreihenfolge ist also Lexikalik, Syntax und Semantik. Der Compiler durchläuft diese Schritte, bevor er den Bytecode erzeugen kann. ### 2.1.1 Textkodierung durch Unicode-Zeichen Java kodiert Texte durch Unicode-Zeichen. Jedem Zeichen ist ein eindeutiger Zahlenwert (engl. code point) zugewiesen, sodass zum Beispiel das große »A« an Position 65 liegt. Der Unicode-Zeichensatz beinhaltet die ISO US-ASCII-Zeichen [http://en.wikipedia.org/wiki/ASCII ] von 0 bis 127 (hexadezimal 0x00 bis 0x7f, also 7 Bit) und die erweiterte Kodierung nach ISO8859 - 1 (Latin-1), die Zeichen von 128 bis 255 hinzunimmt. In den letzten Jahren hat sich der Unicode-Standard erweitert, und Java ist den Erweiterungen gefolgt. Die Java-Versionen von 1.0 bis 1.4 nutzen den Unicode-Standard 1.1 bis 3.0, der für jedes Zeichen 16 Bit reserviert. So legt Java jedes Zeichen in 2 Byte ab und ermöglicht die Kodierung von mehr als 65 000 Zeichen. Ab Java 5 ist der Unicode-4.0-Standard möglich, der 32 Bit für die Abbildung eines Zeichens nötig macht. Die Entwickler haben allerdings für ein Java-Zeichen nicht die interne Länge angehoben, sondern zwei 16-Bit-Zeichen – ein Surrogate-Paar – bilden in der UTF-16-Kodierung ein Unicode-4.0-Zeichen. Diese Surrogate vergrößern den Bereich der Basic Multilingual Plane (BMP).
Hinweis Obwohl Java intern alle Zeichenfolgen in Unicode kodiert, ist es ungünstig, Klassennamen zu wählen, die Unicode-Zeichen enthalten. Einige Dateisysteme speichern die Namen im alten 8-Bit-ASCII-Zeichensatz ab, sodass Teile vom Unicode-Zeichen verloren gehen.
#### Schreibweise für Unicode-Zeichen/Unicode Escapes Da ein Java-Compiler alle Eingaben als Unicode verarbeitet, kann er grundsätzlich Quellcode mit deutschen Umlauten, griechischen Symbolen und chinesischen Schriftzeichen verarbeiten. Allerdings ist es gut zu überlegen, ob ein Programm direkt Unicode-Zeichen enthalten sollte, denn Editoren [Ein Unicode-Editor unter Windows ist SC UniPad unter http://www.unipad.org/main/. ] haben mit Unicode-Zeichen oft ihre Schwierigkeiten – genauso wie Dateisysteme. Beliebige Unicode-Zeichen lassen sich für den Compiler jedoch über Unicode Escapes mit \uxxxx schreiben, wobei x eine hexadezimale Ziffer ist – also 0...9, A...F (beziehungsweise a...f). Diese sechs ASCII-Zeichen, die das Unicode beschreiben, lassen sich in jedem ASCII-Texteditor schreiben, sodass kein Unicode-fähiger Editor nötig ist. Unicode-Zeichen für deutsche Sonderzeichen sind folgende:
Tabelle 2.1 Deutsche Sonderzeichen in Unicode
Zeichen | Unicode
Ä, ä | \u00c4, \u00e4
Ö, ö | \u00d6, \u00f6
Ü, ü | \u00dc, \u00fc
ß | \u00df
Beispiel Deklariere und initialisiere eine Variable :
    double \u03C0 = 3.141592653589793;
Die Unicode-Escape-Sequenzen sind an beliebiger Stelle erlaubt, wo auch sonst ein Zeichen stehen würde. So lässt sich an Stelle eines Anführungszeichens alternativ \u0027 schreiben, was der Compiler als gleichwertig ansieht. Das Unicode-Zeichen \uffff ist nicht definiert und kann bei Zeichenketten als Ende-Symbol verwendet werden. #### Anzeige der Unicode-Zeichen Die Darstellung der Zeichen – besonders auf der Konsole – ist auf einigen Plattformen noch ein Problem. Die Unterstützung für die Standardzeichen des ASCII-Alphabets ist dabei weniger ein Problem als die Sonderzeichen, die der Unicode-Standard definiert. Unter ihnen ist der beliebte Smiley :-), der als Unicode \u263A (WHITE SMILING FACE) und \u2369 (WHITE FROWNING FACE) :-( definiert ist. Das Euro-Zeichen ist unter \u20ac zu finden.
Tipp Sofern sich die Sonderzeichen und Umlaute auf der Tastatur befinden, sollten keine Unicode-Kodierungen Verwendung finden. Der Autor von Quelltext sollte seine Leser nicht zwingen, eine Unicode-Tabelle zur Hand zu haben. Die Alternativdarstellung lohnt sich daher nur, wenn der Programmtext bewusst unleserlich gemacht werden soll.
Ein Versuch, den Smiley auf die Standardausgabe zu drucken, scheitert oft an der Fähigkeit des Terminals beziehungsweise der Shell. Hier ist eine spezielle Shell nötig, die aber bei den meisten Systemen noch in der Entwicklung ist. Und auch bei grafischen Oberflächen ist die Integration noch mangelhaft. Es wird Aufgabe der Betriebssystementwickler bleiben, dies zu ändern. [Mit veränderten Dateiströmen lässt sich dies etwas in den Griff bekommen. So kann man beispielsweise mit einem speziellen OutputStream-Objekt eine Konvertierung für die Windows-NT-Shell vornehmen, so dass auch dort die Sonderzeichen erscheinen. ] #### Unicode-Tabellen unter Windows Unter Windows legt Microsoft das nützliche Programm charmap.exe für eine Zeichentabelle bei, mit der jede Schriftart auf ihre installierten Zeichen untersucht werden kann. Praktischerweise zeigt die Zeichentabelle auch gleich die Position in der Unicode-Tabelle an. Unter der erweiterten Ansicht lassen sich zusätzlich Unicode-Unterbereiche auswählen, wie etwa Währungszeichen oder unterschiedliche Sprachen. Im Unterbereich Latin finden sich zum Beispiel die Zeichen aus der französischen Schrift (etwa »Ç« mit Cedille unter 00c7) und spanischen Schrift (»ñ« mit Tilde unter 00F1), und bei Allgemeinen Interpunktionszeichen findet sich das umgedrehte (invertierte) Fragezeichen bei 00BF. Hier klicken, um das Bild zu vergrößern Abbildung 2.1 Zeichentabelle unter Windows XP ### 2.1.2 Literale Ein Literal ist ein konstanter Ausdruck. Es gibt verschiedene Typen von Literalen: Die Wahrheitswerte true und false Integrale Literale für Zahlen, etwa 122 Zeichenliterale, etwa 'X' oder '\n' Gleitkommaliterale: 12.567 oder 9.999E-2 Stringliterale für Zeichenketten wie "Paolo Pinkas" ### 2.1.3 Bezeichner Für Variablen (und damit Konstanten), Methoden, Klassen und Schnittstellen werden Bezeichner vergeben – auch Identifizierer (von engl. identifier) genannt –, die die entsprechenden Bausteine anschließend im Programm identifizieren. Unter Variablen sind dann Daten verfügbar, Methoden sind die Unterprogramme in objektorientierten Programmiersprachen, und Klassen sind die Bausteine objektorientierter Programme. Ein Bezeichner ist eine Folge von Zeichen, die fast beliebig lang sein kann (die Länge ist nur theoretisch festgelegt). Die Zeichen sind Elemente aus dem gesamten Unicode-Zeichensatz, und jedes Zeichen ist für die Identifikation wichtig. Das heißt: Ein Bezeichner, der 100 Zeichen lang ist, muss auch immer mit allen 100 Zeichen korrekt angegeben werden. Manche C– und FORTRAN-Compiler sind in dieser Hinsicht etwas großzügiger und bewerten nur die ersten Stellen.
Beispiel Im folgenden Java-Programm sind die Bezeichner fett und unterstrichen gesetzt.
    class Main
    {
      public static void main( String[] args )
      {
        System.out.println( "Hallo Welt" );
      }
    }
Dass String fett und unterstrichen ist, hat seinen Grund, denn String ist eine Klasse und kein eingebauter Datentyp wie int. Zwar wird die Klasse String in Java bevorzugt behandelt – das Plus kann Zeichenketten zusammenhängen –, aber es ist immer noch ein Klassentyp.
#### Aufbau der Bezeichner Jeder Java-Bezeichner ist eine Folge aus Java-Buchstaben und Java-Ziffern, [Ob ein Zeichen ein Buchstabe ist, stellt die Funktion Character.isLetter() fest; ob er ein gültiger Bezeichner-Buchstabe ist, sagen die Funktionen isJavaIdentifierStart() für den Startbuchstaben und isJavaIdentifierPart() für den Rest. ] wobei der Bezeichner mit einem Java-Buchstaben beginnen muss. Ein Java-Buchstabe umfasst nicht nur unsere lateinischen Buchstaben aus dem Bereich »A« bis »Z« (auch »a« bis »z«), sondern auch viele weitere Zeichen aus dem Unicode-Alphabet, etwa den Unterstrich, Währungszeichen (wie die Zeichen für Dollar »$«, Euro »€«, Yen »¥«) oder griechische Buchstaben. Auch wenn damit viele wilde Zeichen als Bezeichner-Buchstaben grundsätzlich möglich sind, sollte doch die Programmierung mit englischen Bezeichnernamen erfolgen. Es ist noch einmal zu erwähnen, dass Java streng zwischen Groß-/Kleinschreibung unterscheidet. Die folgende Tabelle listet einige gültige und ungültige Bezeichner auf.
Tabelle 2.2 Beispiele für Bezeichner in Java
Gültige Bezeichner | Ungültige Bezeichner
mami | 2und2macht4
ichWeißIchMussAndréAnrufen | class
RAPHAEL_IST_LIEB | hose gewaschen
cláss | hurtig!
¥€$ | null
mami ist ein Bezeichner, der nur aus Alphazeichen besteht und daher korrekt ist. Auch ¥€$ ist korrekt. Der Bezeichner zeigt zusätzlich die in Java übliche Bezeichnerbildung; denn besteht dieser aus mehreren einzelnen Wörtern, werden diese einfach ohne Leerzeichen hintereinander gesetzt, jedes Teilwort (außer dem ersten) beginnt jedoch dann mit einem Großbuchstaben. Leerzeichen sind in Bezeichnern nicht erlaubt, und daher ist auch hose gewaschen ungültig. Auch das Ausrufezeichen ist, wie viele Sonderzeichen, ungültig. ichWeißIchMussAndré Anrufen ist jedoch wieder korrekt, auch wenn es ein Apostroph-é enthält. Treiben wir es weiter auf die Spitze, dann sehen wir einen gültigen Bezeichner, der nur aus griechischen Zeichen gebildet ist. Auch der erste Buchstabe ist ein Zeichen, anders als in 2und2macht4. Und class sowie null sind ebenso ungültig, da der Name schon von Java belegt ist.
Hinweis In Java-Programmen bilden sich Bezeichnernamen oft aus zusammengesetzten Wörtern einer Beschreibung. Dies bedeutet, dass in einem Satz wie »schönes Wetter heute« die Leerzeichen entfernt werden und die nach dem ersten Wort folgenden Wörter mit Großbuchstaben beginnen. Damit wird aus dem Beispielsatz anschließend »schönesWetterHeute«. Sprachwissenschaftler nennen diese gemischte Groß- und Kleinschreibung Binnenmajuskel.
Die Tabelle im nächsten Abschnitt zeigt uns, welche Namen wir nicht verwenden können. ### 2.1.4 Reservierte Schlüsselwörter Bestimmte Wörter sind als Bezeichner nicht zulässig, da sie als Schlüsselwörter durch den Compiler besonders behandelt werden. Schlüsselwörter bestimmen die »Sprache« eines Compilers. Nachfolgende Zeichenfolgen sind Schlüsselwörter (beziehungsweise Literale im Fall von true, false und null) [Siehe dazu Abschnitt 3.9 (Keywords) der Sprachdefinition unter http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.9. ] und in Java daher nicht als Bezeichnernamen möglich:
Tabelle 2.3 Reservierte Schlüsselwörter in Java
abstract | continue | for | new | switch
assert | default | goto† | package | synchronized
boolean | do | if | private | this
break | double | implements | protected | throw
byte | else | import | public | throws
case | enum | instanceof | return | transient
catch | extends | int | short | try
char | final | interface | static | void
class | finally | long | strictfp | volatile
const† | float | native | super | while
Obwohl die mit † gekennzeichneten Wörter zurzeit nicht von Java benutzt werden, können doch keine Variablen dieses Namens deklariert werden.
Beispiel Reservierte Schlüsselwörter sind im Folgenden fett und unterstrichen gesetzt.
    class Main
    {
      public static void main( String[] args )
      {
        System.out.println( "Hallo Welt" );
      }
    }
### 2.1.5 Token Ein Token ist eine lexikalische Einheit, die dem Compiler die Bausteine des Programms liefert. Der Compiler erkennt an der Grammatik einer Sprache, welche Folgen von Zeichen ein Token bilden. Für Bezeichner heißt dies beispielsweise: Nimm die nächsten Zeichen, solange auf einen Buchstaben nur Buchstaben oder Ziffern folgen. Eine Zahl wie 1982 bildet zum Beispiel ein Token durch folgende Regel: Lies so lange Ziffern, bis keine Ziffer mehr folgt. Bei Kommentaren bilden die Kombinationen /* und */ ein Token. [Das ist in C(++) unglücklich, denn so wird ein Ausdruck *s/*t nicht wie erwartet geparst. Erst ein Leerzeichen zwischen dem Geteiltzeichen und dem Stern »hilft« dem Parser, die gewünschte Division zu erkennen. ] #### Whitespace Problematisch wird es in einer Sprache immer dann, wenn der Compiler die Token nicht voneinander unterscheiden kann. Daher fügen wir Trennzeichen (engl. whitespace), auch Wortzwischenräume genannt, ein. Zu den Trennern zählen Leerzeichen, Tabulatoren, Zeilenvorschub- und Seitenvorschubzeichen. Außer als Trennzeichen haben diese Zeichen keine Bedeutung. Daher können sie in beliebiger Anzahl zwischen die Token gesetzt werden. Das heißt auch, beliebig viele Leerzeichen sind zwischen Token gültig. Und da wir damit nicht geizen müssen, können sie einen Programmabschnitt enorm verdeutlichen. Programme sind besser lesbar, wenn sie luftig formatiert sind. Folgendes ist alles andere als gut zu lesen, obwohl es der Compiler akzeptiert:
    class _{static long _
    (long __,long  ___) {
    return __==0 ?___+ 1:
    ___==0?_(__-1,1):_(__
    –1,_(__, ___-1)) ;  }
    static  {int _=2 ,___
    = 2;System.out.print(
    "a("+_+','+___+ ")="+
    _ (_,  ___) ) ;System
    .exit(1);}}//(C) Ulli
Neben den Trennern gibt es noch 9 Zeichen, die als Separator definiert werden:
    ; , . ( ) { } [ ]
### 2.1.6 Kommentare Programmieren heißt nicht nur, einen korrekten Algorithmus in einer Sprache auszudrücken, sondern auch, unsere Gedanken verständlich zu formulieren. Dies geschieht beispielsweise durch eine sinnvolle Namensgebung für Programmobjekte wie Klassen, Funktionen und Variablen. Ein selbsterklärender Klassenname hilft den Entwicklern erheblich. Doch die Lösungsidee und der Algorithmus werden auch durch die schönsten Variablennamen nicht zwingend klarer. Damit Außenstehende (und nach Monaten wir selber) unsere Lösungsidee schnell nachvollziehen und später das Programm erweitern oder abändern können, werden Kommentare in den Quelltext geschrieben. Sie dienen nur den Lesern der Programme, haben aber auf die Abarbeitung keine Auswirkungen. #### Unterschiedliche Kommentartypen In Java gibt es zum Formulieren von Kommentaren drei Möglichkeiten: Zeilenkommentare. Sie beginnen mit zwei Schrägstrichen [In C++ haben die Entwickler übrigens das Zeilenkommentarzeichen // aus der Vor-Vorgängersprache BCPL wieder eingeführt, das in C entfernt wurde. ] // und kommentieren den Rest einer Zeile aus. Der Kommentar gilt von diesen Zeichen an bis zum Ende der Zeile, also dem Zeilenumbruchszeichen. Blockkommentare. Sie kommentieren in /* */ Abschnitte aus. Der Text im Blockkommentar darf selbst kein */ enthalten, denn Blockkommentare dürfen nicht geschachtelt sein. JavaDoc-Kommentare. Besondere Blockkommentare, die JavaDoc-Kommentare mit /** */ enthalten. Ein JavaDoc-Kommentar beschreibt etwa die Funktion oder die Parameter, aus denen sich später die API-Dokumentation generieren lässt.
Beispiel Zeilen und Blockkommentar:
    /*
     * Blockkommentar
     */
    // Zeilenkommentar
    System.out.println( "Hallo" );          //  Das grüßt dich
    // System.out.println( "Hallo" );       //  Das grüßt dich (nicht)
Ein Zeilenkommentar darf im Blockkommentar enthalten sein, und Zeilenkommentare können andere Zeilenkommentare enthalten.
#### Kommentare mit Stil Alle Kommentare und Bemerkungen sollten in Englisch verfasst werden, um Projektmitgliedern aus anderen Ländern das Lesen zu vereinfachen. Für allgemeine Kommentare sollten wir die Zeichen // benutzen. Sie haben zwei Vorteile: Bei Editoren, die Kommentare nicht farblich hervorheben – oder bei einer einfachen Quellcodeausgabe auf der Kommandozeile –, lässt sich ersehen, dass eine Zeile, die mit // beginnt, ein Kommentar ist. Den Überblick über einen Quelltext zu behalten, der für mehrere Seiten mit den Kommentarzeichen /* und */ unterbrochen wird, ist schwierig. Zeilenkommentare machen deutlich, wo Kommentare beginnen und wo sie enden. Der Einsatz der Zeilenkommentare eignet sich besser dazu, während der Entwicklungs- und Debug-Phase Codeblöcke auszukommentieren. Benutzen wir zur Programmdokumentation die Blockkommentare, so sind wir eingeschränkt, denn Kommentare dieser Form können wir nicht schachteln. Zeilenkommentare können einfacher geschachtelt werden. Die Tastenkombination + – oder + , was das Kommentarzeichen »/« noch deutlicher macht – kommentiert eine Zeile aus. Eclipse setzt dann vor die Zeile die Kommentarzeichen //. Sind mehrere Zeilen selektiert, kommentiert die Tastenkombination alle markierten Zeilen mit Zeilenkommentaren aus. In einer kommentierten Zeile nimmt ein erneutes + die Kommentare einer Zeile wieder zurück. ### 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