Java ist eine relativ junge Programmiersprache, die anfänglich vor allem dadurch Furore machte, dass man mit ihrer Hilfe Programme (die sogenannten Applets1) für Webseiten erstellen konnte, die clientseitig ausgeführt werden. Mitte der Neunziger war dies eine Sensation. Nicht nur weil die Programme clientseitig ausgeführt wurden (diesen Vorteil konnte auch das ungefähr zeitgleich erscheinende JavaScript verbuchen), sondern weil hinter den Applets eine mächtige Programmiersprache stand, die den Webdesignern Möglichkeiten eröffnete, an die bei Verwendung von JavaScript nicht im Traum zu denken war.
Heute hat sich dieses Bild etwas gewandelt. Zum einem hat sich Java immer mehr als professionelle Programmiersprache etabliert, mit der man nicht nur kleine Applets für Webseiten, sondern auch echte Programme schreiben kann. Zum anderen können viele Webseiten-Elemente, die früher nur mit Java-Applets befriedigend zu realisieren waren, heute mit Hilfe alternativen, einfacher zu erlernenden Technologien (JavaScript, PHP, Flash, etc.) implementiert werden. Trotzdem ist Java nach wie vor eine Schlüsseltechnologie für die Erstellung dynamischer Webseiten, so dass wir Ihnen eine fundierte Einführung in die Erstellung und Nutzung von Applets nicht vorenthalten wollen.
Bevor wir zu den Applets kommen, möchte ich noch ein paar allgemeine Worte zu Java verlieren.
In der Einführung zu JavaScript haben wir bereits angesprochen, dass ausführbare Programme aus einer Folge von in Bitfolgen codierten Maschinencode bestehen. Der vom Programmierer verfasste Quellcode eines Programms muss daher mit Hilfe eines Interpreters oder Compilers in Maschinencode umgewandelt werden. Das Problem dabei ist, dass die verschiedenen Plattformen (Kombinationen aus Prozessorarchitektur und Betriebssystem: Microsoft Windows/Intel, UNIX/Sparc, MacOS/PowerPC, etc.) unterschiedlichen Maschinencode benötigen.
Was bedeutet dies für Java-Programme? Java wurde so konzipiert, dass es plattformunabhängig ist. Für Applets ist dies eine absolute Grundvoraussetzung. Wenn Sie ein Applet in eine Webseite einbauen, müssen Sie ja davon ausgehen, dass Ihre Webseiten von Websurfern angefordert werden, die ganz unterschiedliche Rechnerarchitekturen verwenden (manche Websurfer haben Linux-PCs, andere Windows- oder Mac-Rechner).
Daraus folgt, dass Java-Programme interpretiert werden müssen.
Java-Interpreter kann man sich von der Website http.//java.sun.com herunterladen. Die großen Browser verfügen bereits über eingebaute Java-Interpreter.
Die Interpretation der Programme bringt aber auch Nachteile mit sich:
Aus diesem Grunde werden Java-Programme auch kompiliert.
Nanu? Java-Programme werden kompiliert und interpretiert? Wie soll das denn gehen? Nun ganz einfach: Der Java-Programmierer lässt das fertige Programm vom Java-Compiler in einen allgemeinen, plattformunabhängigen Maschinencode - den sogenannten Bytecode - übersetzen. Diesen Code liefert er aus. Der Anwender übergibt diesen Bytecode dem Java-Interpreter, der daraus plattformspezifischen Code erzeugt und diesen ausführt. Der Zwischenschritt mit dem Bytecode hat den Vorteil, dass die Interpretation schneller abläuft und die Anwender statt des Quelltextes nur kryptischen Binärcode zu Gesicht bekommen.
Abbildung 15.1: Erstellung und Ausführung von Java-Programmen
Begleiten wir doch einmal ein Applet von seiner Erstellung im Editor des Programmierers bis zur Ausführung im Browser eines Websurfers.
Der Applet-Quelltext muss in einer eigenen Datei abgespeichert werden, er kann nicht wie JavaScript-Code direkt in den HTML-Code der Webseite eingefügt werden.
In den HTML-Tags gibt man Namen und Ort des Applets an. Im einfachsten Fall kopiert man die CLASS-Datei des Applets direkt in das Verzeichnis, in dem auch die Webseite steht, in der das Applet aufgerufen wird.
Jetzt machen wir einen Sprung und wechseln zu einem Websurfer, der gerade die Webseite mit dem Applet angesteuert hat.
Hierin unterscheiden sich die Applets übrigens auch von den ActiveX-Elementen, die unter MS Windows-Programmierern recht beliebt sind. Diese werden bei Ausführung auf dem Client-Rechner quasi zu einer Erweiterung des Betriebssystems und unterliegen kaum irgendwelchen Beschränkungen.
Es ist Zeit, mal wieder ein bisschen zu programmieren. Doch bevor wir loslegen können, müssen Sie noch den Java-SDK, die Java-Entwicklungsumgebung von Sun herunterladen und installieren - nicht wegen dem Interpreter (der ist vermutlich bereits in Ihren Browser integriert), sondern wegen des Compilers und den Java-Bibliotheken.
Die aktuelle Version finden Sie jeweils auf der Website http://java.sun.com, derzeit ist es Java 2, Version 1.3. Laden Sie den SDK herunter und installieren Sie ihn wie auf der Website beschrieben.
Abbildung 15.2: Die Java-Website von Sun
Zur Entwicklungsumgebung gehören neben den Java-Bibliotheken und einigen Beispielen vor allem die Kommandozeilenwerkzeuge zum Erstellen und Testen der Java-Programme. Diese Programme verfügen über keine grafische Benutzeroberfläche und können nur von der Konsole (Terminal-Fenster) ausgeführt werden.
javac ist der Java-Compiler. Wenn Sie eine Fehlermeldung erhalten haben, dass der Befehl oder das Programm nicht verfügbar ist, liegt dies daran, dass Ihr System nicht so eingerichtet ist, dass Sie die Java-Werkzeuge von jedem beliebigen Verzeichnis aus aufrufen können. Durchsuchen Sie jetzt Ihre Festplatte nach dem Verzeichnis, in dem javac.exe installiert ist. Wenn Sie die Java-Entwicklungsumgebung unter C:\Java installiert haben, könnte das Verzeichnis beispielsweise C:\Java\jdk2\bin lauten. Wenn Sie jetzt am Prompt zuerst den Pfad zu dem Compiler und dann den Compilernamen eingeben (C:\Java\jdk2\bin\javac), müssten Sie als Antwort eine Beschreibung der Aufrufsyntax für den Compiler sehen.
Immer den Pfad mit angeben zu müssen, ist recht lästig. Bequemer ist es, den Pfad zum Compiler und den anderen Java-Werkzeugen in Ihren Systempfad einzutragen.
neuer Eintrag: PATH=.;c:\;c:\dos;c:\windows;c:\ Java\jdk2\bin
Wenn Sie gar keine PATH-Angabe finden, dann fügen Sie eine neue PATH- Anweisung hinzu.
set path = (/home/myname/jdk2/bin $path)
Nachdem Sie den Computer neu gestartet haben (unter Unix/Linux reicht es, aus- und neu einzuloggen), sollten die Java-Werkzeuge von jedem Verzeichnis aus verfügbar sein (siehe Abbildung 15.3).
Abbildung 15.3: javac wurde gefunden
Anhand eines möglichst einfachen Beispiels wollen wir uns nun mit dem Prozess der Applet-Erstellung vertraut machen. Der Code für ein minimales Applets sieht wie folgt aus.
// Dies ist das erste Applet
import java.awt.Graphics;
import java.applet.Applet;
public class HalloWWW extends Applet
{
public void paint(Graphics gc)
{
gc.drawString("Hallo World Wide Web!",100,50);
}
}
Versuchen wir zu verstehen, wie dieser Code aufgebaut ist. Lassen Sie sich aber nicht verdrießen, wenn nicht alles klar wird. Java ist eine äußerst leistungsfähige und damit auch eine recht komplexe Programmiersprache. Zudem ist Java rein objektorientiert, was bedeutet, dass sich der Programmierer von Anfang an mit einer Reihe von nicht leicht zu verstehenden, objektorientierten Konzepten auseinandersetzen muss (die Objektorientierung reicht in Java überdies viel weiter, als wir es von JavaScript her kennen). Es wäre also ziemlich vermessen, Java an einem einzigen Tag erlernen zu wollen. Wir beschränken uns daher auf die Vorstellung der wichtigsten Konzepte und einiger ausgesuchter Techniken und Syntaxelemente. Dies sollte ausreichen, eigene Ideen für Applets zu realisieren. Wer sich gründlicher und systematischer in Java einarbeiten möchte, der sei an die entsprechende Fachliteratur verwiesen (siehe Anhang E).
Am Anfang unseres Java-Applets steht ein Kommentar. Alle Zeichen einer Zeile, die nach dem // erscheinen, werden von dem Java-Compiler als Kommentar angesehen und ignoriert, da sie nur für den Programmierer als Gedächtnisstütze dienen sollen. Bei kleinen Programmen sind Kommentare noch nicht so wichtig, aber bei etwas größeren Programmierprojekten sind sie unverzichtbar, damit der Programmierer oder andere, die den Code lesen wollen, nachvollziehen können, was das Programm an der jeweiligen Stelle macht.
Mehrzeilige Kommentare kann man mit Hilfe der »Klammern« /* und */ einfügen:
/* Dies ist
alles
Kommentar */
Die nächsten Zeilen des Beispiels sehen schon ziemlich wild aus und wir werden uns langsam von außen nach innen vorarbeiten.
import java.awt.Graphics;
import java.applet.Applet;
public class HalloWWW extends Applet
{
}
Hier wird eine Klasse2 mit dem Namen HalloWWW definiert. Da Java rein objektorientiert ist, bestehen Java-Programme praktisch nur aus Klassendefinitionen. Das muss man erst einmal wirken lassen. In Java kann man Anweisungen nicht wie in JavaScript frei in den Quelltext schreiben. In Java gibt es auch keine Funktionen, sondern nur Methoden (Funktionen, die Teil einer Klasse sind). Wenn wir also mit Java programmieren, definieren wir Klassen mit Datenelementen und Methoden und schreiben alle auszuführenden Anweisungen in die Methoden der Klasse.
Die Definition einer Klasse beginnt mit dem Schlüsselwort class, gefolgt von dem Namen der neuen Klasse (in diesem Beispiel HalloWWW).
class HalloWWW
{
}
In den Java-Bibliotheken gibt es viele fertige Klassen, die von Java bereitgestellt werden. Eine solche Klasse ist die Klasse Applet, die eine Reihe von Methoden enthält, die für die Applet-Programmierung wichtig sind: paint(), init(), start(), stop() und destroy(). Damit wir diese Methoden auch für unsere Applet-Klasse HalloWWW nutzen können, geben wir Applet als Basisklasse unserer Applet-Klasse an.
Tatsächlich wird unser Programm überhaupt erst dadurch zu einem Applet, dass wir die Hauptklasse des Programms von der Basisklasse Applet ableiten.
class HalloWWW extends Applet
{
}
Das Schlüsselwort extends teilt dem Compiler mit, dass unsere Klasse HalloWWW alle Elemente der angegebenen Basisklasse (Applet) erben soll.
Jetzt gibt es nur noch ein Problem. Die Java-Bibliotheken sind sehr umfangreich und enthalten einige hundert Klassen. Würde der Compiler den Programmen automatisch alle Klassen aus diesen Bibliotheken zur Verfügung stellen, müsste er für jedes Programm standardmäßig Hunderte von Namen verwalten. Aus diesem Grunde stellt der Compiler nur einige wenige Klassen automatisch zur Verfügung, den Rest muss man explizit importieren. Dies geschieht mit Hilfe der import-Anweisungen am Anfang des Programms:
import java.awt.Graphics;
import java.applet.Applet;
class HalloWWW extends Applet
{
}
Die Klassen der Java-Bibliothek sind in Paketen (englisch packages) organisiert. Benötigt man mehrere Klassen eines solchen Pakets braucht man die Klassen nicht einzeln zu importieren. Mit Hilfe des *-Zeichens kann man alle Klassen eines Pakets auf einmal importieren. So importiert beispielsweise die Anweisung import java.awt.* alle Klassen aus dem awt-Paket.
Zu guter Letzt müssen wir der Klassendeklaration noch das Schlüsselwort public voranstellen:
import java.awt.Graphics;
import java.applet.Applet;
public class HalloWWW extends Applet
{
}
Das Schlüsselwort public ist einer von drei Zugriffsmodifizierer (public, protected, private), die regeln, inwieweit andere Teile des Codes auf diese Klasse zugreifen können. Die Hauptklasse eines Applets muss unbedingt mit dem Modifizierer public deklariert werden - sonst hätte der Browser keine Berechtigung das Applet, das er mit der Webseite geladen hat, auszuführen.
Auch wenn es vielleicht gar nicht so aussieht, aber unsere Klasse HalloWWW enthält jetzt - dank der Ableitung von der Klasse Applet - tatsächlich bereits fünf Methoden namens paint(), init(), start(), stop() und destroy(). Und das ist auch gut so, denn wenn der Browser das Applet ausführt, ruft er genau diese Methoden auf:
Unser Applet ist jetzt zwar funktionsfähig, aber es macht noch nichts. Um es zum Leben zu erwecken, überschreiben wir die von der Basisklasse Applet geerbten Methoden (in diesem Abschnitt begnügen wir uns damit, die paint()-Methode zu überschreiben).
Eine Methode zu überschreiben, bedeutet, die Signatur der Methode (Name, Parameter, Rückgabewert) zu übernehmen und mit einem neuen Anweisungsteil zu verbinden. Die paint()-Methode, die wir von der Basisklasse Applet gerbt haben und die der Browser zum Zeichnen des Applets aufruft, hat beispielsweise folgende Signatur:
void paint(java.awt.Graphics gc)
Indem wir diese Methode mit einem eigenen Anweisungsteil versehen, können wir steuern, wie das Applet im Browser aussehen soll. Zuvor sollten wir aber noch ein paar Worte zu obiger Methodensignatur verlieren. (Wir haben Sie gewarnt: selbst einfachste Java-Programme konfrontieren den Programmierneuling mit einer Flut an neuen Konzepten.)
Java ist - im Gegensatz zu JavaScript - eine streng typisierte Sprache. Das bedeutet, dass jede Variable, jede Methode und jede Klasse, die wir verwenden wollen, vorab deklariert3 werden muss und dass zu jeder Deklaration einer Variablen, eines Methodenparameters oder eines Methodenrückgabewertes ein Datentypangabe gehört. Dabei unterscheidet Java zwischen
Elementare Datentypen sind beispielsweise Ganzzahlen, einzelne Zeichen, Boolesche Werte (siehe Tabelle 15.1).
Variablen von elementaren Datentypen tauchen in Java-Programmen nur als Datenelemente von Klassen, als Parameter von Methoden oder als Rückgabewerte von Methoden auf.
Die zusammengesetzten Datentypen sind nichts anderes als die uns bekannten Klassen. Jede Klassendefinition definiert auch einen neuen Datentyp. Objekte einer Klasse sind daher »Variablen« vom Typ ihrer Klasse. (Wobei es keinen Unterschied macht, ob die Klasse aus der Java-Bibliothek stammt oder von Ihnen im Programm neu definiert wurde.)
Mit diesem Hintergrundwissen können wir die Signatur der paint()-Methode etwas besser verstehen:
void paint(java.awt.Graphics gc).
paint() ist eine Methode, die einen einzigen Parameter (dem wir hier den Namen gc gegeben haben) vom Typ der Klasse java.awt.Graphics definiert. Ihr Rückgabetyp ist void, was besagt, dass die Methode keinen Wert zurückliefert.
Zurück zu unserem Applet-Code. Dort wurde die paint()-Methode wie folgt überschrieben:
public void paint(Graphics gc)
{
gc.drawString("Hallo World Wide Web!",100,100);
}
Denken Sie daran, dass die paint()-Methode vom Browser aufgerufen wird. Dieser übergibt ihr ein Objekt vom Typ der Klasse java.awt.Graphics, das den Teil der Webseite repräsentiert, den das Applet einnimmt. (Dass wir beim Überschreiben Graphics statt java.awt.Graphics schreiben können, liegt daran, dass wir weiter oben java.awt.Graphics importiert haben.)
Der Parameter gc repräsentiert jetzt für uns eine Art Leinwand, in die wir mit Hilfe der Methoden der Klasse Graphics zeichnen können. Alle Zeichenoperationen, die wir auf gc ausführen, werden sofort im Applet sichtbar.
Im obigen Beispiel begnügen wir uns damit, einen Text in das Applet zu zeichnen. Dazu dient die Methode gc.drawString(), die als Parameter die einzuzeichnende Zeichenkette »Hallo World Wide Web!« erhält sowie die x- und y-Koordinaten der Stelle, an der der Text angezeigt werden soll.
Das Grundgerüst eines Java-Applets besteht aus einer Hauptklasse, die von der vordefinierten Klasse java.applet.Applet abgeleitet und als public deklariert wird.
import java.applet.Applet;
public class KLASSENNAME extends Applet
{
}
Von der Basisklasse Applet erbt die Hauptklasse die Methoden: paint(), init(), start(), stop() und destroy(). Will man etwas in den Bereich, den das Applet in der Webseite einnimmt, ausgeben, überschreibt man die geerbte paint()-Methode und zeichnet die Ausgabe in den gc-Parameter.
Achten Sie bei allen Schlüsselwörtern und Bezeichnern (Namen von Klassen, Packages, Methoden, Variablen) auf die Groß- und Kleinschreibung!
Um dieses - und jedes andere - Applet auf Ihrem Computer zu erstellen und auszuführen, gehen Sie wie folgt vor:
Dies ist ganz wichtig. Wenn die Applet-Klasse, wie in unserem Beispiel HalloWWW heißt, muss die Datei unter den Namen HalloWWW.java abgespeichert werden, wobei sogar die Groß- und Kleinschreibung zu berücksichtigen ist.
:> javac HalloWWWW.java
Haben sich keine Tippfehler in den Code eingeschlichen, sollte in dem Verzeichnis danach die .class-Datei des Applets zu finden sein (HalloWWW.class).
Bevor wir das Applet ausführen und austesten können, müssen wir noch eine passende HTML-Seite aufsetzen, die das Applet aufruft.
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Erstes Applet</title>
</head>
<body>
<p>Webseite ruft Applet. Bitte antworten.</p>
<applet code="HalloWWW.class" width="300" height="100"></applet>
</body>
</html>
Hier wird das Applet mit Hilfe des <applet>-Tags eingebettet. Das ist derzeit immer noch gängige Praxis, obwohl das <applet>-Tag seit HTML 4 als deprecated eingestuft ist und eigentlich nicht mehr verwendet werden sollte. Statt dessen empfiehlt der Standard das <object>-Tag. Die Einbettung von Applets mit dem <object>-Tag (siehe unten), wird derzeit aber nur vom Netscape 6-Browser unterstützt. Man ist also gut beraten, im Augenblick noch dem <applet>-Tag den Vorzug zu geben.
Notwendige Attribute für das <applet>-Tag sind:
Wenn das Applet nicht im gleichen Verzeichnis wie das HTML-Dokument steht (genauer gesagt, nicht im aktuellen Verzeichnis), müssen Sie im codebase-Attribut den absoluten oder relativen Pfad zur Applet-Datei angeben. Wenn beispielsweise die HTML-Datei im Verzeichnis c:\meinServer\html steht und der Appletcode im Verzeichnis c:\meinServer\applets, dann wird codebase folgendermaßen gesetzt:
<applet code="HalloWWW.class"
codebase="../applets"
widht="100" height="80">
</applet>
Optional kann man mit dem align-Attribut die Ausrichtung des Applets im umgebenden Text steuern:
align="left" | |
align="right" | |
align="top" | |
align="middle" | |
align="bottom" |
Tabelle 15.2: Ausrichtungsmöglichkeiten für Applets
Mit Hilfe des <object>-Tags sähe die Einbettung des Applets wie folgt aus:
<p>
<object codetype="application/java" classid="java:HalloWWW.class"
width="300" height="100">
Sorry, Ihr Browser unterstützt keine Java-Applets.</object>
</p>
Derzeit unterstützt aber wie gesagt nur der Netscape 6-Browser diese Syntax. (Dafür hapert es bei ihm mit dem korrekten Neuzeichnen der Applets - jedenfalls galt dies für das erste Release des Browsers.)
Aus der Arbeit mit Funktionen und Methoden wissen Sie, dass man Funktionen oder Methoden, die Daten verarbeiten, in vielen Fällen vielseitiger einsetzen kann, wenn die Daten als Parameter übergeben werden. So wäre eine drawString-Methode, die immer den gleichen Text ausgibt, ziemlich nutzlos (außer man will ausgerechnet diesen einen Text ausgeben). Eine drawString-Methode, die einen beliebigen Text ausgibt, den man als Argument beim Aufruf übergibt, ist dagegen sehr vielseitig verwendbar.
Gleiches gilt für Applets. Aber wer könnte überhaupt den Parametern eines Applets Argumente übergeben? Richtig, die Webseite - oder genauer gesagt, der HTML-Code, der das Applet einbettet.
Parameter an Applets werden mit dem <param>-Tag übergeben (das zusammen mit dem <applet> wie auch dem <object>-Tag verwendet werden kann). Es können beliebig viele Parameter angegeben werden. Jeder einzelne Parameter ist durch seinen Parameternamen (name-Attribut) und einen Wert (value-Attribut) definiert.
Die Webseite aus Listing 15.3 bettet ein Applet namens Parameter.class ein und übergibt ihm einen Text, den das Applet ausgeben soll.
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Erstes Applet</title>
</head>
<body>
<p>Webseite ruft Applet. Bitte antworten.</p>
<applet code="Parameter.class" width="300" height="100">
<param name="text" value="Hallo vom Applet" />
</applet>
</body>
</html>
Jetzt müssen wir noch das dazugehörige Applet aufsetzen, das diesen Parameter einliest und verarbeitet.
// Parameterübergabe für Applets
import java.awt.Graphics;
import java.applet.Applet;
public class Parameter extends Applet
{
public void paint(Graphics gc)
{
String str;
str = getParameter("text");
gc.drawString(str,100,50);
}
}
Obiges Listing ist eine einfache Erweiterung des HalloWWW.java-Listings. Da wir die Quelldatei unter einem anderen Namen abgespeichert haben (Parameter.java) müssen wir auch den Namen der Hauptklasse ändern.
Nicht vergessen! Der Name der .java-Datei und der Name der Hauptklasse des Applets müssen identisch sein (einschließlich Berücksichtigung der Groß- und Kleinschreibung).
Der eigentliche Code zur Entgegennahme und Verarbeitung des HTML-Parameters erfolgt in der paint()-Methode. Zuerst deklarieren wir eine String-Variable, in der wir das vom HTML-Code übergebene Argument abspeichern wollen. Java kennt keinen elementaren Datentyp für Strings (der Datentyp char ist nur für einzelne Zeichen). Als Ersatz gibt es in den Java-Bibliotheken eine eigene Klasse String, mit der man Text bearbeiten kann.
String str;
erzeugt also ein Objekt str vom Typ der Klasse String.
Als Nächstes nehmen wir den HTML-Parameter entgegen. Dazu rufen wir die Methode getParameter() auf. Wo kommt diese Methode her? Wir haben Sie zusammen mit den anderen Applet-Methoden (paint(), init(), start(), etc.) von der Basisklasse Applet geerbt.
Da die Methode getParameter() bereits in der Basisklasse so definiert wurde, dass sie einzelne Argumente vom HTML-Code entgegen nimmt und als Ergebnis zurückliefert, gibt es für uns keinen Grund diese Methode zu überschreiben (wie wir es mit paint() getan haben. Wir rufen Sie also einfach auf.
Vielleicht fragen Sie sich jetzt, warum getParameter() einfach so aufgerufen werden kann, während wir die Methode drawString() über das Objekt gc aufrufen müssen? |
Grundsätzlich gilt: Wenn Sie in einer Methode einer Klasse A eine andere Methode der Klasse A aufrufen wollen, brauchen Sie dafür kein Objekt. Sie rufen die Methode einfach auf. Wenn Sie dagegen in einer Methode einer Klasse A eine Methode einer anderen Klasse B aufrufen wollen (wie im Falle der Graphics-Methode drawString(), die wir in der Applet-Methode paint() aufrufen), brauchen Sie ein Objekt der anderen Klasse B.
Wenn wir die Methode getParameter() aufrufen, übergeben wir ihr als Argument den Namen des HTML-Parameters, den die Methode zurückliefern soll. In unserem Beispiel heißt der Parameter "text". Dafür liefert uns die Methode den Wert des value-Attributs dieses Parameters.
Wir speichern den Wert in unserem str-Objekt und geben dieses wie gehabt aus:
str = getParameter("text");
gc.drawString(str,100,50);
Nachdem Sie den Quelltext des Applets kompiliert haben, können Sie die zugehörige Webseite in Ihren Browser laden und das Applet testen.
Abbildung 15.6: Ausgabe von Text, der als HTML-Parameter übergeben wurde
Die Methode getParameter() liefert die Werte der HTML-Parameter immer als Strings zurück. Wenn Sie Zahlen als Argumente übergeben wollen, müssen Sie den zurückgelieferten String erst in die entsprechende Zahl umwandeln. Des geschieht mit Hilfe spezieller Methoden:
Sting str;
int param1;
str = getParameter("Param1");
param1 = Integer.valueOf(str).intValue();
Obiges Beispiel hat einen kleinen Makel. Die paint()-Methode wird jedes Mal aufgerufen, wenn der Browser entscheidet, dass das Applet neu gezeichnet werden muss. Dies ist zum Beispiel der Fall,
Unschön ist, dass dabei jedes Mal der HTML-Parameter abgefragt wird. Effizienter wäre es, den Parameter (der sich ja nicht ändert) nur einmal, beim Laden der Webseite, abzufragen. Dazu brauchen wir nur die geerbte init()-Methode zu überschreiben.
// Parameterübergabe für Applets
import java.awt.Graphics;
import java.applet.Applet;
public class Parameter2 extends Applet
{
String str;
public void init()
{
str = getParameter("text");
}
public void paint(Graphics gc)
{
gc.drawString(str,100,50);
}
}
Hier wird der HTML-Parameter in der init()-Methode abgefragt und in der paint()- Methode ausgegeben. Damit das str-Objekt in beiden Methoden verfügbar ist, müssen wir es als Datenelement am Anfang der Klassendefinition deklarieren.
Variablen, die am Anfang einer Klassendeklaration definiert werden, können von allen Methoden der Klasse benutzt werden (im Gegensatz zu lokalen Variablen, die in einer Methode definiert werden und nur in dieser Methode verwendet werden können). Man bezeichnet sie auch als Instanzvariablen.
Wenn ein Applet in eine Webseite eingefügt wird, wird ihm vom HTML-Code durch die <applet>-Argumente width und height eine begrenzte Fläche zur freien Verfügung gestellt. Diese Fläche ist quasi Benutzeroberfläche und Ausgabefläche unseres Applets. In der paint()-Methode können wir in diese Fläche zeichnen.
Warum erzeugt man die Ausgaben eines Applets gerade in paint() und nicht in einer beliebigen anderen Methode des Applets?
Nun, grundsätzlich kann man tatsächlich von jeder Applet-Methode aus in das Applet zeichnen. Die paint()-Methode bietet aber zwei wichtige Vorteile:
Alle Zeichenmethoden, die wir benötigen, sind in der Klasse Graphics definiert.
Tabelle 15.3: Auswahl einiger Methoden der Klasse Graphics
Was kann man mit diesen Methoden anfangen? Nun, eine ganze Menge. Sie müssen nur noch wissen, dass
Das Applet zu diesem Abschnitt ist ein einfacher Fleckengenerator, dass sieben Flecke einer Farbe, aber unterschiedlicher Radien und Mittelpunkte ausgibt. Wir wollen das Applet so implementieren, dass die Farbe beim Laden des Applets und die Radien und Mittelpunkte der Flecke beim Starten festgelegt werden.
Wir beginnen damit, dass wir in der Applet-Klasse eine untergeordnete Hilfsklasse namens Scheibe definieren. Diese Klasse verfügt über Instanzvariablen, in denen man den Mittelpunkt und den Radius eines einzelnen Flecks speichern kann.
// Der Fleckengenerator
import java.awt.*;
import java.applet.*;
public class Spot extends Applet
{
class Scheibe
{
int m_x, m_y; // Mittelpunkt
int m_r; // Radius
}
Scheibe[] m_flecken; // Array von Scheibe-Objekten
Color m_farbe;
Unter der Hilfsklasse Scheibe haben wir ein Array-Objekt namens m_flecken erzeugt. Da das Array-Objekt mit dem Datentyp Scheibe deklariert wurde, kann man in dem Array auch nur Objekte vom Typ Scheibe abspeichern (geschieht in der init()-Methode).
Als zweite Instanzvariable der Klasse Spot haben wir m_farbe definiert. m_farbe ist vom Typ der vordefinierten Java-Klasse Color, und wir werden in ihr die Farbe für die Flecken speichern.
Nachdem die Instanzvariablen deklariert sind, kommen wir zur init()-Methode.
public void init()
{
// Flecken erzeugen
m_flecken = new Scheibe[7];
for(int i = 0; i < m_flecken.length; i++)
{
m_flecken[i] = new Scheibe();
}
//Farbe festlegen
m_farbe = new Color((int) (255*Math.random()),
(int) (255*Math.random()),
(int) (255*Math.random()) );
}
Wir beginnen damit, dass wir der Instanzvariablen m_flecken einen Wert zuweisen. m_flecken erwartet als »Wert« ein Array-Objekt. Objekte von Klassentypen werden in Java immer mit Hilfe des new-Operators und des Konstruktors der Klasse erzeugt.
m_flecken = new Scheibe[7];
erzeugt also ein Array-Objekt, das sieben Scheibe-Objekte aufnehmen kann, und weist dieses Objekt der Instanzvariablen m_flecken zu.
Damit haben wir aber noch nicht die einzelnen Scheibe-Objekte erzeugt. Dies geschieht in der anschließenden for-Schleife.
for- und while-Schleifen funktionieren in Java ganz so wie in JavaScript (siehe Kapitel 9.3).
Zum Schluss erzeugt die init()-Methode ein neues Color-Objekt und speichert es in der Instanzvariablen m_farbe.
Farbobjekte werden - wie in vielen Programmiersprachen üblich - als RGB-Farben definiert, das heißt man mischt die Farbe aus Rot-, Grün- und Blau-Anteilen zusammen. Jeder Farbanteil bekommt dabei einen Werte zwischen 0 (kein Farbanteil) und 255 (voller Farbanteil) zugewiesen. Die Mischung erfolgt nach dem Prinzip der Lichtfarben, das heißt, Color(255, 255, 255) wäre Weiß. (Für die wichtigsten Farben gibt es vordefinierte Werte: Color.black, Color.red, etc.)
Jetzt müssen wir noch festlegen, wo die Flecken eingezeichnet werden sollen und wie groß sie sein sollen. Den Code hierfür setzen wir in der start()-Methode auf (obwohl man ihn auch in init() einfügen könnte).
public void start()
{
//Mittelpunkte und Radien festlegen
for(int i = 0; i < m_flecken.length; i++)
{
m_flecken[i].m_x = (int) (400*Math.random());
m_flecken[i].m_y = (int) (200*Math.random());
m_flecken[i].m_r = (int) (50*Math.random());
}
}
Zu guter Letzt geben wir die Flecken aus:
public void paint(Graphics gc)
{
gc.setColor(m_farbe);
for(int i = 0; i < m_flecken.length; i++)
{
gc.fillOval(m_flecken[i].m_x,
m_flecken[i].m_y,
m_flecken[i].m_r * 2,
m_flecken[i].m_r * 2);
}
}
} // Ende von Spot.java
Zuerst richten wir mit Hilfe der Graphics-Methode setColor() den Farbwert in m_farbe als neue Zeichenfarbe ein.
gc.setColor(m_farbe);
Dann gehen wir in einer Schleife die einzelnen Scheibe-Objekte durch und zeichnen sie in das Applet.
Zum Zeichnen von ausgefüllten Scheiben verwendet man die Methode fillOval(). Dieser übergibt man als Argumente die Koordinaten der linken, oberen Ecke und die Breite und Höhe eines rechteckigen Ausgabebereichs. In diesen Ausgabebereich zeichnet die Methode die Scheibe formatfüllend ein. (Um kreisförmige Scheiben einzuzeichnen, übergibt man einfach gleiche Werte für Breite und Höhe.)
Listing 15.7: Spot.html - das HTML-Dokument zum Anzeigen des Applets
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Fleckenapplet</title>
</head>
<body>
<p>Dieses Dokument dient der Demonstration des Fleckengenerators.</p>
<hr />
<applet code="Spot.class" width="400" height="200"></applet>
<hr />
</body>
</html>
Nachdem Sie das Applet kompiliert haben, sollten Sie es in verschiedenen Browsern testen. Wenn Sie es beispielsweise in den Internet Explorer 5 oder den Netscape 6-Browser laden, können Sie sehen, dass bei jedem Aktualisieren (Neuladen) der Webseite die Farbe und die Positionen/Radien der Flecke neu festgelegt werden.
Wenn Sie die Webseite mit dem Applet dagegen in den Netscape Navigator 4 laden, und dann auf die Schaltfläche Neu laden drücken, werden Sie feststellen, dass sich nur die Position und die Größe der Flecken ändert, nicht aber die Farbe. Dies liegt daran, dass der Navigator 4 das Applet selbst nicht neu lädt, sondern nur die start()-Methode erneut aufruft. Soll das Applet ganz neu geladen (und init() aufgerufen) werden, müssen Sie den Neu laden-Schalter zusammen mit der (Shift)-Taste drücken.
Zum Testen können Sie die Webseite mit dem Applet auch in den Appletviewer des Java- SDK laden. Rufen Sie dazu den Appletviewer wie folgt von der Konsole aus auf:
prompt:> appletviewer spot.html
Im Appletviewer finden Sie dann eine Reihe von Schaltern, mit denen Sie das Starten, Stoppen oder Neuladen des Applets simulieren können.
Das Grundprinzip der Ereignisverarbeitung unter Java ist das gleiche wie unter JavaScript. Mit Maus und Tastatur löst der Anwender auf den verschiedenen Elementen eines Applets Ereignisse aus. Wurde für eines der ausgelösten Ereignisse eine Behandlungsmethode eingerichtet, wird der Code dieser Methode ausgeführt.
Die Frage ist nun, wie man eine solche Behandlungsmethode einrichten kann?
Zuerst überlegt man sich, für welches »Element« man welches Ereignis abfangen möchte. In Java kann man Ereignisse für das Applet oder für die im Applet enthaltenen Steuerelemente abfangen. Da wir über die Erzeugung und Einbindung von Steuerelementen in Java noch nichts gehört haben (und im Verlaufe dieses Buches auch nichts weiter erfahren werden, sorry!), werden wir uns ein Applet-Ereignis aussuchen.
Für die Applet-Programmierung sind besonders die Mausereignisse interessant (Klick mit der Maus, Maus wird über das Applet bewegt, etc.). Unter diesen Ereignissen greifen wir uns das Mausklickereignis heraus. Unser Ziel soll es sein, ein Applet zu implementieren, das Mausklicke abfängt und an der Stelle des Mausklicks eine Meldung ausgibt.
Java hält für die verschiedenen Ereignisse eine Reihe von vordefinierten Methoden bereit. Diese Methoden sind in Interfaces und Adapter-Klassen organisiert. Der Einfachheit halber werden wir uns hier auf die Adapter-Klassen konzentrieren.
Die Adapter-Klassen für die Mausereignisse heißen MouseAdapter und MouseMotionAdapter.
Das Erste, was wir tun werden, ist daher die Methode mouseClicked zu überschreiben. Dazu sind drei Schritte nötig.
import java.awt.event.*;
class MeinMausLauscher extends MouseAdapter
{
}
class MeinMausLauscher extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{
// auszuführender Code
}
}
Danach brauchen wir die Ereignisbehandlungsmethode nur noch mit dem Applet zu verbinden. Hierfür verfügt das Applet über eine geerbte Methode namens addMouseListener(). Dieser übergeben wir ein Objekt unserer Mauslauscher-Klasse.
MeinMausLauscher obj = new MeinMausLauscher();
addMouseListener(obj);
Falls man das MeinMausLauscher-Objekt, das mit new MeinMausLauscher() erzeugt wird, nur dazu braucht, um es an die Methode addMouseListener() zu übergeben, kann man den obigen Code vereinfachen, indem man das Objekt direkt im Methodenaufruf erzeugt. Es wird dann automatisch an den Parameter der Methode übergeben.
addMouseListener(new MeinMausLauscher());
Den vollständigen Code für unser Applet sehen Sie in Listing 15.8
// Mausklicks
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class Mausklick extends Applet
{
String meldung;
int x, y;
class MeinMausLauscher extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{
meldung = "Mausklick bei (" + String.valueOf(e.getX())
+ "," + String.valueOf(e.getY()) + ")";
x = e.getX();
y = e.getY();
repaint();
}
}
public void init()
{
addMouseListener(new MeinMausLauscher());
setBackground(Color.red); // roter Applet-Hintergrund
}
public void paint(Graphics gc)
{
gc.drawString(meldung, x, y);
}
}
Die mouseClicked-Methode beginnt damit, dass sie die auszugebende Meldung aufbaut. Diese besteht aus einem Text (»Mausklick bei«) und den Koordinaten des Mausklicks. Die Koordinaten des Mausklicks können wir mit Hilfe der Methoden getX() und getY() vom dem MouseEvent-Parameter der mouseClicked-Methode abfragen. Leider sind die zurückgelieferten Koordinaten echte Ganzzahlen. Wir müssen die Koordinaten daher zuerst in Strings umwandeln (mit Hilfe der Methode String.valueOf()). Den vollständig aufgebauten Meldungsstring weisen wir der Instanzvariablen meldung zu.
Anschließend speichern wir die Koordinaten des Mausklicks in den Instanzvariablen x und y und fordern das Applet auf, sich selbst neu zu zeichnen.
Rufen Sie die paint()-Methode nie direkt auf, wenn Sie möchten, dass das Applet aktualisiert wird. Rufen Sie stattdessen die Methode repaint() auf.
Heute haben wir Sie ein wenig in die Programmierung mit Java und in die Erstellung von Applets für Webseiten eingeführt. Etliche wichtige Techniken konnten wir dabei nur kurz erläutern, etliche weitere interessante Aspekte und Möglichkeiten konnten wir nicht einmal anreißen:
Immerhin, Sie wissen jetzt, wie Applets funktionieren, und sollten in der Lage sein, eigene einfache Applets zu erstellen und in Ihre Webseiten einzubinden. Außerdem haben Sie Grundkenntnisse erworben, die Ihnen morgen, wenn wir eine Laufschrift als Beispiel für eine Applet-Animationen erstellen, zugute kommen werden.
Wenn Sie sich gründlicher und tiefer in die Programmierung mit Java einarbeiten wollen, besorgen Sie sich entsprechende Fachliteratur (siehe Anhang E) oder laden Sie sich das Java-Tutorial von der Sun-Website java.sun.com herunter.
Heute haben Sie gelernt, wie man mit Java Applets für Webseiten erstellt.
Sie haben die Website http://java.sun.com besucht, von der man sich stets die aktuelle Java- Entwicklungsumgebung und aktuelle Dokumentationen und Tutorien herunterladen kann.
Wir haben Sie in die Arbeit mit den Java-Entwicklungswerkzeugen vertraut gemacht, und vielleicht haben Sie dabei sogar ein bisschen mehr über die Konsole Ihres Betriebssystems erfahren.
Danach haben wir unser erstes Applet erstellt, kompiliert und mit Hilfe des <applet>-Tags in eine Testwebseite eingebunden:
<applet code="HalloWWW.class"
widht="100" height="80">
</applet>
Die Programmiersprache Java ist rein objektorientiert und daher nicht einfach zu erlernen. So mussten Sie sich heute mit einer Vielzahl von neuen Konzepten, Techniken und Syntaxformen auseinandersetzen. Vielleicht hat Sie die Sprache Java dennoch fasziniert und Sie haben - obwohl die Applets, die wir heute erstellt haben, aus didaktischen Gründen möglichst einfach und deswegen weniger praxisrelevant waren - eine Ahnung davon bekommen, wie leistungsfähig und mächtig diese Sprache ist. Vielleicht fühlen Sie sich von Java aber auch ein wenig überfordert. Dann sollten Sie nicht verzagen, sondern sich darüber freuen, dass man viele Dinge auch mit JavaScript realisieren kann.
Frage:
Auf der Buch-CD ist eine Version der Java-Entwicklungsumgebung enthalten. Sollte ich
trotzdem die aktuelle Version von der Java-Website herunterladen?
Antwort:
Nein. Um die Beispiele aus diesem Buch nachzuvollziehen und sich in Java
einzuarbeiten, ist die auf der Buch-CD befindliche Version absolut ausreichend.
Wenn Sie allerdings professionell in die Java-Programmierung einsteigen wollen,
sollten Sie sich von Zeit zu Zeit auf der Java-Sun-Website umsehen, ob nicht eine
aktuellere Version der Java-Entwicklungsumgebung angeboten wird und sich
diese gegebenenfalls herunterladen.
Antwort:
Java verfügt über zwei Sammlungen von Steuerelementen: AWT-Steuerelemente
und Swing-Steuerelemente. Die AWT-Steuerelemente sind so implementiert, dass
Sie auf die in den Betriebssystemen der Anwender integrierten Steuerelemente
zurückgreifen, die Swing-Steuerelemente tun dies nicht. Während sich das
Aussehen der AWT-Steuerelemente daher immer an das Betriebssystem des
Anwenders anpasst, hat man bei Verwendung der Swing-Steuerelemente die
Wahl, ob man das Erscheinungsbild anpassen lassen oder fest vorgeben möchte.
Swing ist noch relativ neu, aber es ist abzusehen, dass es sich bald durchsetzen und zumindest die alten AWT-Steuerelemente verdrängen wird. Wenn Sie nach Literatur zu Java Ausschau halten, achten Sie daher unbedingt darauf, dass in den Büchern Swing berücksichtigt wird.
Der Workshop enthält Quizfragen, die Ihnen helfen sollen, Ihr Wissen zu festigen, und Übungen, die Sie anregen sollen, das eben Gelernte umzusetzen und eigene Erfahrungen zu sammeln. Versuchen Sie, das Quiz und die Übungen zu beantworten und zu verstehen, bevor Sie zur Lektion des nächsten Tages übergehen.
