Übersicht der Java-Sprache
von Laura Lemay
Dieser Anhang enthält eine Übersicht über die Java-Sprache und dient als Nachschlageteil für dieses Buch.
Das ist keine Übersicht über die Syntax oder die Techniken der Sprache. Vielmehr dient der Teil zum Nachschlagen von Informationen zu Themen, die Sie in den Lektionen dieses Buches gelernt haben. Wenn Sie eine technische Beschreibung der Sprache benötigen, besuchen Sie am besten den Java-Web-Standort (http://java.sun.com) und laden Sie die Spezifikation herunter (enthält auch die volle BNF-Syntax).
Schlüsselwörter und Symbole sind in serifenloser Schrift angegeben. Argumente und andere zu ersetzende Teile sind in serifenloser Schrift Kursiv abgesetzt.
Optionen stehen zwischen Klammern (abgesehen vom Array-Abschnitt). Sind mehrere Optionen verfügbar, die sich gegenseitig ausschließen, werden sie durch ein Pipe-Zeichen getrennt, z. B.:
[ public private protected ] type varname
Die folgenden Wörter sind für die Java-Sprache reserviert (die teilweise im derzeitigen Release noch nicht benutzt werden). Sie können diese Wörter nicht für Namen von Klassen, Methoden oder Variablen verwenden.
abstract boolean break byte case cast catch char class const continue default | do double else extends final finally float for future generic goto if | implements import inner instanceof int interface long native new null operator outer | package private protected public rest return short static sure switch synchronized this | throw throws transient try var void volatile while |
/* Das ist ein mehrzeiliger Kommentar */
// Das ist ein einzeiliger Kommentar
/** Javadoc-Kommentar */
|
number
number[l [|] L] 0xhex 0Xhex 0octal [ number ].number number[ f [|] f] number[ d [|] D] [ + [|] - ] number numberenumber numberEnumber 'character' "characters" "" \b \t \n \f \r \Ó \Õ \\ \uNNNN true false |
Typ int
Typ long Hex integer Hex integer Octal integer Typ double Typ float Typ double Mit Vorzeichen Exponent Exponent Einzelnes Zeichen Zeichenkette Leere Zeichenkette Rückschritt Tabulator Zeilenvorschub Blattvorschub Wagenrücklauf Doppeltes Anführungszeichen Einfaches Anführungszeichen Backslash Unicode-Escape (NNNN ist hex) Boolesch Boolesch |
| [ byte | short | int | long ] varname | Ganzzahlen (eine auswählen) |
| [ float | double ] varname | Gleitpunktzahlen (einen Typ auswählen) |
| char varname | Zeichen |
| boolean varname | Boolesche Variable |
| classname varname | Klassen-Typen |
| interfacename varname | Schnittstellen-Typen |
| type varname, varname, varname | Mehrere Variable |
| [ static ] variableDeclaration | Klassenvariablen |
| [ final ] variableDeclaration | Konstanten |
| [ public | private | protected ] variableDeclaration | Zugriffskontrolle |
| [volatile] varname | Asynchron modifiziert |
| [transient] varname | (noch nicht implementiert) |
| variable = value | Zuweisung |
| variable++ | Postfix-Inkrement |
| ++variable | Präfix-Inkrement |
| variable-- | Postfix-Dekrement |
| --variable | Präfix-Dekrement |
| variable += value | Addieren und zuweisen |
| variable -= value | Subtrahieren und zuweisen |
| variable *= value | Multiplizieren und zuweisen |
| variable ÷= value | Dividieren und zuweisen |
| variable %= value | Modulus und zuweisen |
| variable &= value | AND und zuweisen |
| variable = value | OR und zuweisen |
| variable ^= value | XOR und zuweisen |
| variable <<= value | Nach links verschieben und zuweisen |
| variable >>= value | Nach rechts verschieben und zuweisen |
| variable >>>= value | Mit Nullen auffüllen, nach rechts verschieben und zuweisen |
| arg + arg | Addition |
| arg - arg | Subtraktion |
| arg * arg | Multiplikation |
| arg ÷ arg | Division |
| arg % arg | Modulus |
| arg < arg | Kleiner als |
| arg > arg | Größer als |
| arg <= arg | Kleiner als oder gleich |
| arg >= arg | Größer als oder gleich |
| arg == arg | Gleich |
| arg - arg | Nicht gleich |
| arg && arg | Logisches AND |
| arg ¦ ¦ arg | Logisches OR |
| ! arg | Logisches NOT |
| arg & arg | AND |
| arg ¦ arg | OR |
| arg ^ arg | XOR |
| arg << arg | Nach links verschieben |
| arg >> arg | Nach rechts verschieben |
| arg >>> arg | Mit Nullen auffüllen und nach rechts verschieben |
| ~ arg | Komplement |
| (type)thing | Umwandlung |
| arg instanceof class | Instanz von |
| test ? trueOp : falseOp | Ternärer (if) Operator |
| new class() | Neue Instanz erstellen |
| new class(arg,arg,arg...) | Neue Instanz mit Parametern |
| object.variable | Instanzvariable |
| object.classvar | Klassenvariable |
| Class.classvar | Klassenvariable |
| object.method() | Instanzmethode (ohne Argumente) |
| object.method(arg,arg,arg...) | Instanzmethode |
| object.classmethod() | Klassenmethode (ohne Argumente) |
| object.classmethod (arg,arg,arg...) | Klassenmethode |
| Class.classmethod() | Klassenmethode (ohne Argumente) |
| Class.classmethod (arg,arg,arg...) | Klassenmethode |
Die Klammern in diesem Abschnitt sind Teil des Arrays bzw. der Zugriffsanweisungen und bedeuten keine alternativen Optionen wie in den vorherigen Abschnitten.| type varname[] | Array-Variable |
| type[] varname | Array-Variable |
| new type[numElements] | Neues Array-Objekt |
| array[index] | Elementzugriff |
| array.length | Array-Länge |
|
if ( test ) block if ( test ) block | Bedingung |
| else block | Bedingung mit else |
| switch (test) { | switch (nur für int- und char-Typen) |
case value : statement
case value : statement
...
default : statement
}
| |
| for (initializer, test, change ) block | for-Schleife |
| while ( test ) block | while-Schleife |
do block while (test) | do-Schleife |
| break [ label ] | break von Schleife oder switch |
| continue [ label ] | Kontinuierliche Schleife |
| label: | Beschriftete Schleife |
| class classname block | Einfache Klassendefinition |
| Die folgenden optionalen Modifier können in die Klassendefinition eingefügt werden: | |
| [ final ] class classname block | Keine Subklassen zulässig |
| [ abstract ] class classname block | Keine Instanzen zulässig |
| [ public ] class classname block | Zugriff außerhalb des Pakets |
| class classname [ extends Superclass ] block | Superklasse definieren |
|
class classname [ implements interfaces ]
block | Eine oder mehrere Schnittstellen implementieren |
| returnType methodName() block | Basismethode |
| returnType methodName(parameter, parameter, ...) block | Methode mit Parametern |
Methodenparameter sehen so aus:type parameterName | |
| Methodenvariationen können eines der folgenden optionalen Schlüsselwörter enthalten: | |
| [ abstract ] returnType methodName() block | Abstrakte Methode |
| [ static ] returnType methodName() block | Klassenmethode |
| [ native ] returnType methodName() block | Native Methode |
| [ final ] returnType methodName() block | final-Methode |
| [ synchronized ] returnType methodName() block | Thread-Sperre vor Ausführung |
| [ public | private | protected ] returnType methodName() | Blockzugriffskontrolle |
| Constructors sehen so aus: | |
classname() block | Basis-Constructor |
| classname(parameter, parameter, parameter...) block | Constructor mit Parametern |
| [ public | private | protected] classname()block | Zugriffskontrolle |
Im Methoden-/Constructor-Körper können folgende Referenzen und Methoden verwendet werden:
this | Verweist auf das aktuelle Objekt |
super | Verweist auf eine Superklasse |
super.methodName() | Ruft die Methode einer Superklasse auf |
this(...) | Ruft den Constructor einer Klasse auf |
super(...) | Ruft den Constructor der Superklasse auf |
return [ value ] | Gibt einen Wert aus |
import package.className
| Importiert die bezeichnete Klasse | |
| import package.* | Importiert alle Klassen im Paket |
| package packagename | Klassen in dieser Datei gehören zu diesem Paket |
| synchronized ( object ) block | Wartet auf Sperre von object |
try block | Geschützte Anweisungen |
| catch ( exception ) block | Wird im Fall von exception ausgeführt |
| [ finally block ] | Reinigungscode |
try block[ catch ( exception ) block ] finally block | Wie im vorherigen Beispiel (kann wahlweise catch oder finally, jedoch nicht beides benutzen) |
Copyright ©1996 Markt&Technik