Lokale Variablen verdecken gleichnamige Instanz- oder Klassenvariablen. Durch Voranstellen des this-Zeigers kann trotzdem auf sie zugegriffen werden. Dies wird in Java oft ausgenutzt, um im Konstruktor einer Methode Membervariablen zu initialisieren, die denselben Namen wie formale Parameter haben.

Unterschiedliche Konstruktoren einer Klasse können in Java verkettet werden, d.h. sie können sich gegenseitig aufrufen. Der aufzurufende Konstruktor wird dabei als eine normale Methode angesehen, die über den Namen this aufgerufen werden kann. Die Unterscheidung zum bereits vorgestellten this-Pointer nimmt der Compiler anhand der runden Klammern vor, die dem Aufruf folgen. Alternativ zu diesen beiden Varianten, einen Superklassenkonstruktor aufzurufen, ist es auch erlaubt, mit Hilfe der this-Methode einen anderen Konstruktor der eigenen Klasse aufzurufen. Um die oben erwähnten Zusagen einzuhalten, muss dieser allerdings selbst direkt oder indirekt schließlich einen Superklassenkonstruktor aufrufen.

Java hat Threads direkt in die Sprache integriert und mit den erforderlichen Hilfsmitteln als Konstrukt zur Realisierung der Nebenläufigkeit implementiert. Ein Thread ist ein eigenständiges Programmfragment, das parallel zu anderen Threads laufen kann. Ein Thread ähnelt damit einem Prozess, arbeitet aber auf einer feineren Ebene. Während ein Prozess das Instrument zur Ausführung eines kompletten Programms ist, können innerhalb dieses Prozesses mehrere Threads parallel laufen. Der Laufzeit-Overhead zur Erzeugung und Verwaltung eines Threads ist relativ gering und kann in den meisten Programmen vernachlässigt werden. Ein wichtiger Unterschied zwischen Threads und Prozessen ist der, dass alle Threads eines Programmes sich einen gemeinsamen Adressraum teilen, also auf dieselben Variablen zugreifen, während die Adressräume unterschiedlicher Prozesse streng voneinander getrennt sind.

Die Implementierung von Threads war eine explizite Anforderung an das Design der Sprache. Threads sollen unter anderem die Implementierung grafischer Anwendungen erleichtern, die durch Simulationen komplexer Abläufe oft inhärent nebenläufig sind. Threads können auch dazu verwendet werden, die Bedienbarkeit von Dialoganwendungen zu verbessern, indem rechenintensive Anwendungen im Hintergrund ablaufen.

Threads werden in Java durch die Klasse Thread und das Interface Runnable implementiert. In beiden Fällen wird der Thread-Body, also der parallel auszuführende Code, in Form der überlagerten Methode run zur Verfügung gestellt. Die Kommunikation kann dann durch Zugriff auf die Instanz- oder Klassenvariablen oder durch Aufruf beliebiger Methoden, die innerhalb von run sichtbar sind, erfolgen. Zur Synchronisation stellt Java das aus der Betriebssystemtheorie bekannte Konzept des Monitors zur Verfügung, das es erlaubt, kritische Abschnitte innerhalb korrekt geklammerter Programmfragmente und Methoden zu kapseln und so den Zugriff auf gemeinsam benutzte Datenstrukturen zu koordinieren.

Darüber hinaus bietet Java Funktionen zur Verwaltung von Threads. Diese erlauben es, Threads in Gruppen zusammenzufassen, zu priorisieren und Informationen über Eigenschaften von Threads zu gewinnen. Das Scheduling kann dabei wahlweise unterbrechend oder nichtunterbrechend implementiert sein. Die Sprachspezifikation legt dies nicht endgültig fest, aber in den meisten Java-Implementierungen wird dies von den Möglichkeiten des darunter liegenden Betriebssystems abhängen.

[Verwalten von Threads]

throw AusnahmeObjekt;

Die Behandlung von Fehlern folgt den üblichen Regeln. Sie entspricht damit genau dem Fall, wenn anstelle der throw-Anweisung eine aufgerufene Methode denselben Fehler ausgelöst hätte: Zunächst wird in den umgebenden Blöcken nach einem Fehler-Handler gesucht. Falls das erfolglos ist, wird der Fehler an den Aufrufer weitergegeben.

Die throw-Anweisung kann nicht nur dazu verwendet werden, neue Fehler auszulösen. Sie kann ebenfalls eingesetzt werden, um innerhalb der catch-Klausel einer try-catch-Anweisung das übergebene Fehlerobjekt erneut zu senden. In diesem Fall wird nicht noch einmal dieselbe catch-Klausel ausgeführt, sondern der Fehler wird gemäß den oben genannten Regeln an den umgebenden Block bzw. den Aufrufer weitergegeben.

Auch selbstdefinierte Ausnahmen müssen sich an die catch-or-throw-Regel halten. Wird die Ausnahme nicht innerhalb derselben Methode behandelt, ist sie mit Hilfe der throws-Klausel im Methodenkopf zu deklarieren und weiter oben in der Aufrufkette zu behandeln.

Es gibt verschiedene Arten von Typkonvertierungen in Java. Mit Hilfe des Type-Cast-Operators dürfen alle legalen Typkonvertierungen vorgenommen werden. Der Type-Cast-Operator wird vor allem dann angewendet, wenn der Compiler keine impliziten Konvertierungen vornimmt; beispielsweise bei der Zuweisung von größeren an kleinere numerische Typen oder bei der Umwandlung von Objekttypen.

Der Rückgabetyp einer Methode trägt nicht zu ihrer Unterscheidung bei. Zwei Methoden, die sich nur durch den Typ ihres Rückgabewertes unterscheiden, werden also als gleich angesehen. Da Methoden auch ohne die Verwendung ihres Rückgabewerts aufgerufen werden können (was typischerweise wegen ihrer Nebeneffekte geschieht), hätte weder der Compiler noch der menschliche Leser in diesem Fall die Möglichkeit, festzustellen, welche der überladenen Varianten tatsächlich aufgerufen werden soll.

Das Überladen von Methoden ist dann sinnvoll, wenn die gleichnamigen Methoden auch eine vergleichbare Funktionalität haben. Eine typische Anwendung von überladenen Methoden besteht in der Simulation von variablen Parameterlisten (die als Feature direkt in Java nicht zur Verfügung stehen). Auch, um eine Funktion, die bereits an vielen verschiedenen Stellen im Programm aufgerufen wird, um einen weiteren Parameter zu erweitern, ist es nützlich, diese Funktion zu überladen, um nicht alle Aufrufstellen anpassen zu müssen.

· Instanzvariablen, die im Rahmen einer Klassendefinition definiert und zusammen mit dem Objekt angelegt werden.

· Klassenvariablen, die ebenfalls im Rahmen einer Klassendefinition definiert werden, aber unabhängig von einem konkreten Objekt existieren.

· Lokale Variablen, die innerhalb einer Methode oder eines Blocks definiert werden und nur dort existieren.

Daneben betrachtet die Sprachdefinition auch Array-Komponenten und die Parameter von Methoden und Exception-Handlern als Variablen.

Eine Variable in Java ist immer typisiert. Sie ist entweder von einem primitiven Typen oder von einem Referenztypen. Mit Ausnahme eines Spezialfalls bei Array-Variablen, auf den wir später zurückkommen, werden alle Typüberprüfungen zur Compile-Zeit vorgenommen. Java ist damit im klassischen Sinne eine typsichere Sprache. Die Deklaration einer Variable erfolgt in der Form:

Typname Variablenname;
Typname VariablenName = InitialerWert;

Die Deklaration einer lokalen Variable gilt in Java als ausführbare Anweisung. Sie darf daher überall dort erfolgen, wo eine Anweisung verwendet werden darf. Die Sichtbarkeit einer lokalen Variable erstreckt sich von der Deklaration bis zum Ende des umschließenden Blocks.

Lokale Variablen dürfen sich nicht gegenseitig verdecken. Es ist also nicht erlaubt, eine bereits deklarierte Variable x in einem tiefer geschachtelten Block erneut zu deklarieren. Das Verdecken von Klassen- oder Instanzvariablen dagegen ist zulässig und wird besonders häufig in Konstruktoren bei der Initialisierung von Instanzvariablen verwendet.

Vererbungen können mehrstufig sein, d.h. eine abgeleitete Klasse kann Basisklasse für weitere Klassen sein. Auf diese Weise können vielstufige Vererbungshierarchien entstehen, die in natürlicher Weise die Taxonomie (also die gegliederte Begriffsstruktur) der zu modellierenden Anwendungswelt repräsentieren. Vererbungshierarchien werden wegen ihrer Baumstruktur auch als Ableitungsbäume bezeichnet. Sie werden meist durch Graphen dargestellt, in denen die abgeleiteten Klassen durch Pfeile mit den Basisklassen verbunden sind und die Basisklassen oberhalb der abgeleiteten Klassen stehen.

Jede Methode in Java ist typisiert. Der Typ einer Methode wird zum Zeitpunkt der Definition festgelegt und bestimmt den Typ des Rückgabewerts. Dieser kann von einem beliebigen primitiven Typ, einem Objekttyp (also einer Klasse) oder vom Typ void sein. [return]

Das Abstract Windowing Toolkit von Java enthält verschiedene Fensterklassen, die über eine gemeinsame Vererbungshierarchie miteinander in Verbindung stehen. Oberste Fensterklasse ist Component, daraus wurde Container abgeleitet. Container ist die Oberklasse der beiden Klassen Window und Panel. Während Window sich in die Unterklassen Frame und Dialog verzweigt, wird aus Panel die Klasse Applet abgeleitet. Unterhalb von Dialog gibt es noch den Standard-File-Dialog in der Klasse FileDialog.

Zum Ableiten einer eigenen Fensterklasse wird in der Regel entweder die Klasse Frame oder die Klasse Dialog verwendet, die beide aus Window abgeleitet sind. Dialog wird vorwiegend dafür verwendet, Dialogboxen zu erstellen, um die dafür vorgesehen, modale oder nicht-modale Dialoge zu realisieren (die über enthaltene Komponenten mit dem Anwender kommunizieren). Ein modaler Dialog ist ein Fenster, das immer im Vordergrund des Fensters bleibt, von dem es erzeugt wurde, und das alle übrigen Fensteraktivitäten und Ereignisse so lange blockiert, bis es geschlossen wird. Ein nicht-modaler Dialog kann mit anderen Fenstern koexistieren und erlaubt es, im aufrufenden Fenster weiterzuarbeiten.Die wichtigste Klasse zur Ausgabe von Grafiken in Java-Applikationen ist Frame.

Ein Empfänger für Window-Events muss das Interface WindowListener implementieren und bekommt Events des Typs WindowEvent übergeben. WindowEvent erweitert die Klasse ComponentEvent und stellt neben getID und getSource die Methode getWindow zur Verfügung, mit der das Fenster ermittelt werden kann, das die Nachricht ausgelöst hat. Die Registrierung der Empfängerklasse erfolgt mit der Methode addWindowListener, die in den Klassen Dialog und Frame zur Verfügung steht.

· Das Paket java.util stellt eine Reihe von Verbundklassen zur Verfügung, die beliebige Objekttypen speichern können. Um darin auch elementare Typen ablegen zu können, ist es notwendig, anstelle der primitiven Typen ihre Wrapper-Klassen zu verwenden.

· Da Objektreferenzen den Wert null haben können, kann die Verwendung der Wrapper-Klassen beispielsweise bei der Datenbankprogrammierung nützlich sein. Damit lassen sich primitive Feldtypen darstellen, die NULL-Werte enthalten können.

· Das Reflection-API verwendet Wrapper-Klassen zum Zugriff auf Membervariablen oder Methodenargumente primitiver Typen.

Die Instanzierung einer Wrapper-Klasse kann meist auf zwei unterschiedliche Arten erfolgen. Einerseits ist es möglich, den korrespondierenden primitiven Typ an den Konstruktor zu übergeben, um ein Objekt desselben Werts zu erzeugen. Alternativ kann meist auch ein String an den Konstruktor übergeben werden. Dieser wird in den entsprechenden primitiven Typ konvertiert und dann zur Initialisierung der Wrapper-Klasse verwendet.

[Call by Reference]