2. Die Programmiersprache Java

Sie erhalten immer eine Hilfe zu den Programmen, wenn Sie sie ohne Parameter aufrufen. Desweiteren befindet sich eine genaue Beschreibung aller Optionen und Programmfunktionen in der HTML-Online-Dokumentation. Die folgenden Informationen stellen nur eine kleine Übersicht dar.
Ein Programm mit der Endung "_g" ist immer die ohne Optimierung compilierte (debugbare) Version.

Allgemeines:

javac- der Java-Compiler übersetzt die Java-Quelltexte in den Bytecode
Beispiel: javac -classpath src;src\old -d classes -O -deprecation test.java
kompiliert die Quelldatei test.java in src oder src\old, gibt Fehlermeldungen zu veralteten Aufrufen aus, führt eine Optimierung durch und speichert die Klassendatei im Pfad classes.

java - der Java-Interpreter führt Programme im Bytecode aus.
Beispiel: java -cs ls cpp
führt das Programm "ls.class" mit dem Parameter "cpp" aus und übergibt an den java-Interpreter die Option -cs.

Im Unterschied zu C unterstützt die Sprache JAVA nicht alle Standard-C-Operatoren.
Es gleichen sich jedoch die Vorrangs- und Assoziativitätsregeln. Java unterstützt jedoch beispielsweise nicht den Operator sizeof. Da es auch keine Pointer gibt (statt dessen Referenzen), existieren auch der Adress- und Pointeroperator nicht.
Neu ist beispielsweise, der "+"-Operator zum Verketten von Strings. Der instanceof-Operator liefert true oder false je nachdem, ob ein Object eine Instanz einer angegebenen Klasse ist oder nicht.
Zum normalen >> (shift right) Operator kommt der >>>-Operator, der eine Zahl grundsätzlich als nicht vorzeichenbehaftet behandelt.
Werden & und | (bitweises AND und OR) auf boolean-Typen angewandt, wirken Sie automatisch wie logisches AND und OR, mit dem Unterschied, daß bei && und || der auf der rechten Seite stehende Operand nicht mehr ausgeführt wird, sobald das Ergebnis der Auswertung des linken Operanden schon feststeht. Boolean ist ein eigenständiger Typ, daher kann nicht jeder Typ als boolean-Typ verwendet werden, sondern andere Typen müssen mittels Vergleichsoperationen umgewandelt werden.
In Java werden Zugriffe auf Felder über deren Grenzen hinaus nicht wie in C zugelassen, sondern erzeugen Ausnahmen. Typen sind in Java streng definiert, im Gegensatz zu C, wo man nie weiß, ob beispielsweise char auf dem aktuellen Compiler signed oder unsigned ist. Der Ausweg war oft, eigene Typen zu definieren, und dann immer den eigenen Typ, z.B. byte als unsigned char zu benutzen, was für Außenstehende zu schwer lesbaren Programmen führte.
Java-Code ist generell sehr gut lesbar, denn durch klar definierte Typen (ein großes Manko von C++), Unterbindung von Operator-Überladung, Pointerarithmetik und anderes (z.B. kann es nicht mehr passieren, daß man bei if(a==0) ein Gleichheitszeichen vergißt), ist alles eindeutig interpretierbar.

Einige Eigenschaften von C++ wurden bei Java weggelassen.

• Operator-Overloading (+,-, ...)
• typedef Statements (eigene Typen, in Java statt dessen Objekte)
• Strukturen, Unions und Funktionen (keine globalen Funktionen)
• Präprozessor (z.B. #define,#ifdef ...)
• goto (dafür benannte Schleifenendziele, u.ä.)
• Zeiger (dafür Referenzen)
• Mehrfachvererbung (Ausnahme: Interfaces)
• Präprozessor (eigene Typen nur als Objekte, import statt #include)

Java bietet auch viel Neues.

• Thread-Modell (unabhängige Tasks innerhalb eines Programmes)
• Automatische Speicherverwaltung (kein explizites Freigeben mehr)
• dynamisches Laden und Binden (late binding)
• Sicherheitsmodell (Überprüfung vor Ausführung)
• portabel ohne Neucompilierung (Bytecode)
• UniCode-Zeichenketten sowie echte Strings und Felder

Java ist eine Fusion von vier Arten der Programmierung.

Object oriented	like Smalltalk
Numeric	like FORTRAN
Systems	like C
Distributed	like nothing else

Java kennt folgende reservierte Wörter, von denen noch nicht alle unterstützt werden:

abstract      boolean       break         byte          byvalue
case          cast          catch         char          class
const         continue      default       do            double
else          extends       false         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        super         switch        synchronized  this
throw         throws        transient     true          try
var           void          volatile      while

Noch nicht unterstützt: byvalue, cast, const, future, generic, goto, inner, operator, outer, rest, var

Kurzzusammenfassung Flußkontrolle

Art	Schlüsselwort
Entscheidung	if-else, switch-case
Schleife	for, while, do-while
Ausnahme	try-catch-finally, throw
anderes	break, continue, label:, return

Java bietet hier in etwa die gleichen Möglichkeiten wie C++.

• if-Verzweigung
  Wenn der Audruck wahr ist, wird Befehl1 ausgeführt, sonst Befehl2.

  if (Ausdruck)
    Befehl1;
  else
    Befehl2;
  

• switch-Verzweigung
  Je nach Wert der Variable wird der entsprechende Zweig ausgeführt. Der Default-Zweig wird ausgeführt, wenn nichts sonst zutrifft.

  switch(Variable) {
    case Konstante :Befehl; break;
    default :Befehl; break;
  }
  

• for-Schleife
  Am Anfang wird die Initialisierung durchgeführt und der Schleifenkörper samt abschließender Inkrementierung solange durchgeführt, bis das Abbruchkriterium false liefert.

  for (Initialisierung; Abbruchkriterium; Inkrement)
    Befehl;
  

• do-Schleife
  Block ausführen, solange der Audruck wahr ist.

  do {
    Befehl;
  } while (Ausdruck);
  

• while-Schleife
  Solange der Audruck wahr ist, wird der folgende Block ausgeführt.

  while (Ausdruck)
    Befehl;
  

• Ausnahmebehandlung
  Wenn im ersten Block eine Ausnahme auftritt, wird diese behandelt, es können auch mehrere catch-Blöcke folgen. Ein finally-Block wird immer ausgeführt.

  try {
    Befehl;
  } catch (Exception e) {
    Behandlung;
  } finally {
    Befehl;
  }
  

Java unterstützt kein goto aber man kann in der Form "label: Befehl" eine Sprungmarke setzen, zu der man mittels "break label" springen kann. In einer Schleife kann man mit "continue" bzw. "continue label" den nächsten Durchlauf einleiten, "break" bricht die Schleife ab. Der return-Befehl beendet die aktuelle Methode und kann auch einen Wert zurückliefern.

Java enthält eine umfangreiche Klassenbliothek.
Das Application Programming Interface (API) enthält vordefinierte Klassen und Methoden, die ein Programm auf dem ausführenden Client voraussetzen kann, d.h., sie müssen nicht mit übertragen werden und gehören zum Sprachstandard.
Da es unumgänglich ist, beim Programmieren die HTML-Version der Java-Dokumentation zur Hand zu haben, wird im Gegensatz zu vielen Büchern, die dies als Füllstoff benutzen, auf eine ausführliche Beschreibung des APIs verzichtet. Besonderheiten werden im dritten Kapitel anhand von Beispielprogrammen erläutert.

Farbcodes in der API-Dokumentation

Farbe	Bedeutung
violett	Instanzvariablen
blau	static-Variablen
gelb	Konstruktoren
rot	Instanzmethoden
grün	static-Methoden

Das Suchen nach geeigneten Klassen und Methoden im API macht einen erheblichen Teil der Programmierung aus. Außerdem sind solche allgemeingültigen Funktionen meist um einiges stabiler als eigene "quick hacks".

Java API Packages

• java.applet
  Basisklasse für in HTML-Seiten eingebundene Programme
• java.awt
  das Abstract Window Toolkit enthält Java's Grafikklassen
• java.awt.datatransfer
  ClipBoard-Funktionalität (Copy/Paste)
• java.awt.event
  Eventhandling
• java.awt.image
  Bildanzeige, Formate, ...
• java.awt.peer
  plattformspezifische Implementationen
• java.beans
  plattformunabhängige custom controls
• java.io
  Ein und Ausgabe, Streams
• java.lang
  standardmäßig eingebundene Klassen wie String, Byte, ...
• java.lang.reflect
  Introspektion, besserer Zugriff auf Klassen durch Debugger und Inspektoren
• java.math
  große Zahlentypen
• java.net
  Netzzugriffe
• java.rmi
  Remote Method Invocation, Zugriff auf Objekte in anderen virtuellen Maschinen
• java.rmi.dgc
  Serverseite des verteilten Garbage collection Algorithmus'
• java.rmi.registry
  managt Datenbank, die RMI-Verbindungen koordiniert
• java.rmi.server
  RMI-Server
• java.security
  Sicherheit durch digitale Signaturen, Schlüssel, ...
• java.security.acl
  Datenzugriffsschutz (Access Control List)
• java.security.interfaces
  Digital Signature Algorithm (DSA) Klassen
• java.sql
  Datenbankzugriffe
• java.text
  Lokalisierung von Texten
• java.util
  verschiedene Toolklassen wie Enumeration, Parser, ...
• java.util.zip
  ZIP- und JAR-Zugriff, CRC-Klassen
• sun.tools.debug
  Basis-Debuggerklassen
• sunw.io
  veraltete Klasse zur Kompatibilität mit Java 1.02 beans
• sunw.util
  veraltete Eventhandling-Klassen

Die begrifflichen Grundlagen hierzu wurden bereits im ersten Kapitel gelegt. Wenn man z.B. in der prozeduralen Programmierung eine Zeichenkette in Kleinbuchstaben umwandeln will, so würde man einfach einer Bibliotheksfunktion den String als Argument liefern und den konvertierten String zurückerhalten. In Java legt man ein neues String-Objekt an, in dem man mit dem new-Operator eine Instanz einer Klasse anlegt, z.B.:

Modifier beschreiben spezielle Eigenschaften von Klassen, Variablen, Methoden...
Die meisten von Ihnen existieren aus Sicherheitsgründen, aber viele haben auch einen starken Einfluß auf Codegröße und Performance. Standardmäßig ist eine Variable im aktuellen Package zugänglich.

synchronized
Methoden, die Engpaßstellen darstellen werden nur exklusiv ausgeführt. So wird verhindert, daß z.B. ein nur halb aktualisierter Eintrag in einer Datenbank gelesen wird.

final
Finale (endgültige) Variablen sind Konstanten. Finale Methoden können durch keine neue Implementation in Subklassen mehr überschrieben werden und von finalen Klassen dürfen keine Subklassen mehr gebildet werden. Da man z.B. finale Methoden in Subklassen nicht überschreiben kann, sollten Passwortabfragen final deklariert werden, außerdem kann der Compiler finalen Code besser optimieren.

abstract
Abstrakte Klassen dürfen abstrakte (unvollständig implementierte) Methoden besitzen. Diese müssen dann Subklassen implementieren. Abstrakte Klassen können nicht instantiiert werden.

static
static- Variablen (Klassenvariablen) und Methoden (implizit final!) gibt es im Gegensatz zu Instanzvariablen nur je einmal pro Klasse und nicht je einmal pro Instanz. Static-Methoden können auch nur mit static-Variablen und Methoden arbeiten.

public
Öffentliche Klassen, Methoden und Variablen sind überall zugänglich, also sowohl importiert als auch in Subklassen.

private
Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse verfügbar und wird auch nicht mitvererbt.

protected
Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse und deren Subklassen verfügbar.

transient
Dieser Modifier wird derzeit noch nicht benutzt und in ist späteren Versionen für Low-Level-Funktionen und Datenbankzugriffe gedacht.

volatile
Dieser Modifier kennzeichnet, daß eine Variable asynchron aktualisiert wird und überwacht Operationen damit besonders.

native
Eine solche Methode wird nicht in Java-Code, sondern in Assembler oder C implementiert (nicht portabel). Siehe dazu die javah-Dokumentation.

Hier finden Sie die kontextfreie Grammatik in der Backus-Naur-Form.

CompilationUnit ::= PackageStatement CompilationBody | CompilationBody

PackageStatement ::= 'package' PackageName ';'

CompilationBody ::= ImportStatementList TypeDeclarationList | TypeDeclarationList | ImportStatementList

ImportStatementList ::= ImportStatementList ImportStatement | ImportStatement

ImportStatement ::= 'import' PackageName '.''*'';' | 'import' ClassName ';' | 'import' InterfaceName ';'

TypeDeclarationList ::= TypeDeclarationList TypeDeclaration | TypeDeclaration

TypeDeclaration ::= ClassDeclaration | InterfaceDeclaration | ';'

ClassDeclaration ::= OptionalModifierList 'class' Identifier SuperClassReference ImplementationReference '{' FieldDeclarationList '}'

SuperClassReference ::= 'extends' ClassName | ;

ImplementationReference ::= 'implements' InterfaceList |

InterfaceList ::= InterfaceList ',' InterfaceName | InterfaceName

FieldDeclarationList ::= FieldDeclarationList FieldDeclaration | FieldDeclaration

FieldDeclaration ::= OptionalDocComment MethodDeclaration | OptionalDocComment ConstructorDeclaration | OptionalDocComment VariableDeclaration | StaticInitializer | ';'

OptionalDocComment ::= DocComment |

MethodDeclaration ::= OptionalModifierlist Type Identifier '(' OptionalParameterList ')' OptionalArrayDeclaratorList OptionalThrowsClause '{' Statement '}' | OptionalModifierlist Type Identifier '(' OptionalParameterList ')' OptionalArrayDeclaratorList OptionalThrowsClause ';'

OptionalArrayDeclaratorList ::= ArrayDeclaratorList |

ArrayDeclaratorList ::= ArrayDeclaratorList '['']' | '['']'

OptionalThrowsClause ::= 'throws' ThrowableList |

ThrowableList ::= Identifier | Identifier , ThrowableList

ConstructorDeclaration ::= OptionalModifierList Type Identifier '(' OptionalParameterList ')' '{' OptionalStatement '}'

VariableDeclaration ::= OptionalModifierList Type VariableDeclaratorList ';'

VariableDeclaratorList ::= VariableDeclaratorList ','VariableDeclarator | VariableDeclarator

VariableDeclarator ::= Identifier ArrayDeclaratorList | Identifier ArrayDeclaratorList '=' VariableInitializer

VariableInitializer ::= Expression | '{' '}' | '{'VariableInitializerList '}' | '{'VariableInitializerList ',''}'

VariableInitializerList ::= VariableInitializerList ',' VariableInitializer | VariableInitializer

StaticInitializer ::= 'static' '{' Statement '}'

OptionalParameterList ::= ParameterList |

ParameterList ::= ParameterList ','Parameter | Parameter

Parameter ::= TypeSpecifier Identifier ArrayDeclaratorList | TypeSpecifier Identifier

StatementList ::= StatementList Statement | Statement

Statement ::= VariableDeclaration | Expression ';' | '{' StatementList '}' | '{' '}' | 'if' '(' Expression ')'Statement | 'if' '(' Expression ')' 'else'Statement | 'while' '(' Expression ')'Statement | 'do' Statement 'while' '(' Expression ')' | 'try' Statement CatchStatementList | 'try' Statement CatchStatementList 'finally' Statement | 'switch' '(' Expression ')' '{' StatementList '}' | 'synchronized' '(' Expression ')' Statement | 'return' Expression ';' | 'return' ';' | 'throw' Expression ';' | 'case' Expression ':' | 'default' ':' | Identifier ':' Statement | 'break' ';' | 'break' Identifier ';' XXX | 'continue' ';' | 'continue'Identifier ';' XXX | ';'

CatchStatementList ::= CatchStatementList 'catch''(' Parameter ')'Statement | 'catch''(' Parameter ')'Statement

Expression ::= Expression '+'Expression | Expression '-' Expression | Expression '*' Expression | Expression '/' Expression | Expression '%' Expression | Expression '^' Expression | Expression '&' Expression | Expression '|' Expression | Expression '&&' Expression | Expression '||' Expression | Expression '<<' Expression | Expression '>>' Expression | Expression '>>>' Expression | Expression '=' Expression | Expression '+=' Expression | Expression '-=' Expression | Expression '*=' Expression | Expression '/=' Expression | Expression '%=' Expression | Expression '^=' Expression | Expression '|=' Expression | Expression '>>=' Expression | Expression '<<=' Expression | Expression ''>>>=' Expression | Expression '<' Expression | Expression '>' Expression | Expression '<=' Expression | Expression '>=' Expression | Expression '==' Expression | Expression '!=' Expression | Expression '.' Expression | Expression ',' Expression | Expression 'instanceof' ( ClassName | InterfaceName ) | Expression '?' Expression ':' Expression | Expression '[' Expression ']' | '++' Expression | '--' Expression | Expression '++' | Expression '--' | '-' Expression | '!' Expression | '~' Expression | '(' Expression ')' | '(' Type ')' Expression | Expression '(' ArgumentList ')' | Expression '(' ')' | 'new' ClassName '(' ')' | 'new' ClassName '(' ArgumentList ')' | 'new' TypeSpecifier ArrayExpressionList | 'new' TypeSpecifier ArrayExpressionList ArrayDeclaratorList | 'new' '(' Expression ')' | 'true' | 'false' | 'null' | 'super' | 'this' | Identifier | Number | String | Character

ArrayExpressionList ::= '[' Expression ']'ArrayExpressionList | '[' Expression ']'

ArgumentList ::= Expression ','ArgumentList | Expression

Type ::= TypeSpecifier | TypeSpecifier ArrayDeclaratorList

TypeSpecifier ::= 'boolean' | 'byte' | 'char' | 'short' | 'int' | 'float' | 'long' | 'double' | ClassName | InterfaceName

OptionalModifierList ::= ModifierList |

ModifierList ::= ModifierList Modifier | ModifierList

Modifier ::= 'public' | 'private' | 'protected' | 'static' | 'final' | 'native' | 'synchronized' | 'abstract' | 'threadsafe' | 'transient'

PackageName ::= Identifier | PackageName '.'Identifier

ClassName ::= Identifier | PackageName '.'Identifier

InterfaceName ::= Identifier | PackageName '.'Identifier

Character ::= 'a' | 'b' | ... | 'A' | 'B' | ...

Digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

Number ::= {Digit}

Special ::= '$' | '_' | '%' | ...

Identifier ::= Character | Special {Character | Special | Digit}

Java unterscheidet zwei Arten von ausführbaren Programmen.
Diese Besonderheit wurde eingeführt, um auf der einen Seite eine vollwertige Programmiersprache zu schaffen, die alle Aufgaben von C übernehmen kann und auf der anderen Seite trotzdem Sicherheitsmechanismen für Internetanwendungen enthält.

Applications sind vollwertige Programme, wie man sie von C her gewohnt ist.
Es gibt eine main()-Funktion, mit der das Programm gestartet wird. Applications können ganz normal auf lokale Dateien zugreifen und man kann praktisch jede Anwendung umsetzen. Sie müssen nicht wie Applets Subklassen von anderen Klassen darstellen oder auf bestimmte Botschaften reagieren und besitzen keinen festgelegten Kontext. Für das Erlernen der Programmiersprache und erste ernsthafte Anwendungen sind Applications ideal, weshalb ihnen das gesamte nächste Kapitel gewidmet ist.

Applets sind Internet-Programme, die keine main()-Funktion besitzen.
Sie werden über den Applet-Tag in HTML-Seiten eingebettet. Zum Starten der Programme ist daher ein W3-Browser nötig, der das Gerüst für das Applet bildet. Es wird eine Benutzeroberfläche aufgebaut und dann auf Ereignisse (Events) wie z.B. Mausklicks gewartet. Vor dem Ausführen werden die Programme gründlich auf Sicherheitsrisiken untersucht und wenn nötig abgebrochen. Applets dürfen nicht auf lokale Dateien zugreifen und auch nur mit dem Server kommunizieren, von dem Sie geladen wurden. Durch das streng Reglement kann kein Applet die ganze Maschine zum Absturz bringen oder vertrauliche Daten an fremde Rechner schicken. Beispiele für Applets, die sich mit Grafik, Menüs, Klangausgabe und anderem befassen, finden sich im Demos-Verzeichnis des JDKs, eine genaue Betrachtung dessen würde den Rahmen dieses Skripts sprengen.

Appletcations sind eine Mischform aus beidem.
Der Begriff taucht nur sehr selten auf. Im wesentlichen handelt es sich um Programme, die man sowohl als Applet als auch als Application starten kann, danach richten sich dann die Einschränkungen. Ein Beispiel dafür findet sich auch im dritten Kapitel.