Die Kontrollstrukturen, Schleifen und Operatoren sind weitgehend die von C oder C++ her bekannten Konstrukte. Lediglich bei den Operatoren mußte, da es keine vorzeichenlosen Zahlen gibt der >>> Operator eingefügt werden, der eine Zahl bitweise nach rechts Schiebt und von rechts Nullen nach schiebt. Im Gegensatz zum >> Operator, der das Vorzeichenbit nach schiebt. In C wurde dies anhand dessen entschieden, ob der Zahlenwert vorzeichenbehaftet war oder nicht.
Auf der nächsten Seite befindet sich die, bis auf die kursiv dargestellten Symbole DocComment, Identifier, Number, String und Character komplette Syntaxbeschreibung der Programmiersprache Java. Die Syntax ist trotz der Objektorientiertheit nicht wesentlich Komplexer als die der Programmiersprache C. Die Fett dargestellten Symbole sind Zeichen wie sie im Quelltext erscheinen. Folgende Notation wird für die Grammatik verwendet:
Ausdruck = Metaausdruck; "|" steht für Alternativen, (...) für Gruppierungen, ? für kein oder einmaliges Auftreten und * für kein oder mehrmaliges Auftreten.
CompilationUnit= PackageStatement? ImportStatement* TypeDeclaration* ;
PackageStatement= package PackageName ; ;
ImportStatement= import PackageName . * ;| import ( ClassName | InterfaceName ); ;
TypeDeclaration= ClassDeclaration | InterfaceDeclaration | ; ;
ClassDeclaration = Modifier* class Identifier (extends ClassName)? (implements InterfaceName (, InterfaceName)*)? { FieldDeclaration* } ;
InterfaceDeclaration = Modifier* interface Identifier (extends InterfaceName (, InterfaceName)*)? { FieldDeclaration* } ;
FieldDeclaration = DocComment? MethodDeclaration | DocComment? ConstructorDeclaration | DocComment? VariableDeclaration | StaticInitializer | ; ;
MethodDeclaration = Modifier* Type Identifier ( ParameterList? ) ( [ ] )* ( { Statement* } | ;) ;
ConstructorDeclaration = Modifier* Identifier ( ParameterList? ) { Statement* } ;
VariableDeclaration= Modifier* Type VariableDeclarator (, VariableDeclarator)* ; ;
VariableDeclarator= Identifier ([ ])* (= VariableInitializer)? ;
VariableInitializer= Expression | { ( VariableInitializer ( , VariableInitializer )* ,? )? } ;
StaticInitializer= static { Statement* } ;
ParameterList = Parameter (, Parameter)* ;
Parameter = TypeSpecifier Identifier ([ ])* ;
Statement = VariableDeclaration | Expression ; | { Statement* } | if ( Expression ) Statement (else Statement)? | while ( Expression ) Statement | do Statement while ( Expression ) ; | try Statement (catch ( Parameter ) Statement)* (finally Statement)? | synchronized ( Expression ) Statement | return Expression? ; | throw Expression ; | switch ( Expression ) { Statement* } | case Expression : | default; | Identifier : Statement | break Identifier? ; | continue Identifier? ; | ; ;
BiOp= + | - | * | / | % | ^ | & | | | && | || | > | >>> | = | += | -= | *= | /= | %= | ^= | &= | |= | = | >>>= | < | > | = | == | != | . | , ;
Expression= Expression BiOp Expression | Expression instanceof ( ClassName | InterfaceName ) | Expression ? Expression : Expression | Expression [ Expression ] | ++ Expression | -- Expression | Expression ++ | Expression -- | - Expression | ! Expression | ~ Expression | ( Expression ) | ( Type ) Expression | Expression ( ArgList? ) | new ClassName ( ArgList?) | new TypeSpecifier ( [ Expression ] )+ ([ ])* | new ( Expression ) | true | false | null | super | this | Identifier | Number | String | Character ;
ArgList = Expression (, Expression )* ;
Type = TypeSpecifier ([ ])* ;
TypeSpecifier= boolean | byte | char | short | int | float | long | double | ClassName | InterfaceName ;
Modifier= public | private | protected | static | final | native | synchronized | abstract | threadsafe | transient ;
PackageName= Identifier | PackageName . Identifier ;
ClassName= Identifier | PackageName . Identifier ;
InterfaceName= Identifier | PackageName . Identifier ;
Java läßt für Bezeichner (Identifier) Zeichen aus dem Unicode zu, das heißt, daß z.B. auch Umlaute in Namen vorkommen können. Diese Möglichkeit bereitet allerdings noch etlichen Dateisystemen Probleme, da die Klassennamen direkt in *.class Files abgelegt werden, daher ist bei der Benennung der Klassen darauf zu achten nur ASCII Zeichen zu verwenden, die auch in üblichen Dateisystemen verwendet werden dürfen. Da einige Betriebsysteme etwas lausig mit dem Vergleich von Dateinamen umgehen (Namentlich z.B. WIN95) sollte auch darauf geachtete werden, daß sich Klassen nicht nur durch Groß- und Kleinschreibung unterscheiden, was in Java generell möglich ist.
Zahlen (Number) werden wie in C üblich dargestellt. char ist immer ein 16Bit Unicode Wert, der entsprechend dargestellt wird 7 Bit ASCII Werte werden direkt in ihre Unicode Entsprechungen transformiert.
Strings werden wie in C üblich durch doppelte Hochkomma eingeschlossen dargestellt. Für die Darstellung von Unicode Zeichen gibt es eine spezielle Escape Darstellung.
Bleiben noch die DocComments, mittels des zur Java Entwicklungsumgebung gehörenden Dokumentencompilers kann aus Java Quelltext eine Dokumentation der Klassenhierarchie und der Klasseninterfaces erstellt werden. Sun hat aus der Not, das der Quelltext sich schneller verändert als die Dokumentation angepaßt wird eine Tugend gemacht und ermöglicht die Dokumentation des Codes direkt im Programmcode unterzubringen.
Um textuelle Beschreibungen in diese Dokumentation einfließen zu lassen gibt es eine spezielle Kommentarklammerung. Der Text zwischen /** und */ wird zur Beschreibung des darauffolgenden Codes (in der Regel eine Definition) verwendet und Automatisch eingebunden. Das erzeugte Dokument wird im HTML Format ausgegeben. Es ist auch möglich im Kommentar HTML Tags zu verwenden die dann in das Dokument übernommen werden. Hyperlinks ermöglichen es die Verschiedenen Hierarchiestufen der Klassen zu verfolgen. In den Kommentaren können dadurch auch HTML Tags z.B. zur Hervorhebung genutzt werden.
|