8
von
Laura Lemay
Die heutige Beliebtheit von Java ist vor allen Dingen der Tatsache zuzuschreiben, daß es Java-fähige WWW-Browser gibt, die Applets unterstützen. Applets sind kleine Programme, die auf einer Webseite ausgeführt werden können um dynamische, interaktive Web Sites zu erstellen. Wie ich am Anfang des Buches bereits erwähnt habe, werden Applets in der Sprache Java geschrieben und können in allen WWW-Browsern dargestellt werden, die Java unterstützen. Vermutlich haben Sie dieses Buch vor allem deshalb gekauft, weil Sie wissen möchten, wie Applets erstellt werden. Lassen Sie uns also keine Zeit mehr vergeuden.
Letzte Woche haben Sie die Grundlagen von Java kennengelernt und bei den meisten kleinen Programmen, die Sie erstellt haben, handelte es sich um Java-Anwendungen. Diese Woche soll auf diesen Grundlagen aufgebaut werden. Sie erfahren, wie Applets erstellt und verwendet werden. Dazu gehört auch die Erläuterung der vielen Klassen in der Standard-Klassenbibliothek von Java.
Heute sollen folgende Themen erläutert werden:
Obwohl die Unterschiede zwischen Java-Anwendungen und Java-Applets am Anfang dieses Buches bereits erläutert wurden, sollen diese noch einmal kurz zusammengefaßt werden.
Java-Anwendungen sind eigenständige Programme, die bereits allein mit dem Java-Interpreter, z.B. von einer Befehlszeile aus, ausgeführt werden können. Beinahe alle Elemente, die Sie bis zu diesem Punkt im Buch verwendet haben, waren Java-Anwendungen – wenn auch einfache.
Java-Applets hingegen werden innerhalb eines WWW-Browser ausgeführt. Der Bezug zum Applet wird mit einem speziellen HTML-Tag auf einer Webseite eingebettet. Wenn der Benutzer eine Webseite mit einem Java-fähigen Browser lädt, in der ein Applet enthalten ist, lädt der Browser das Applet vom Web-Server und führt es auf dem lokalen System aus (also jenem, auf dem der Browser betrieben wird). (Der Java-Interpreter ist in den Browser eingebaut und führt von dort die kompilierte Java-Klassendatei aus.)
Da Java-Applets innerhalb eines Java-Browser ausgeführt werden, können Sie auf jene Struktur zugreifen, die der Browser enthält: ein vorhandenes Fenster, eine Ereignisbehandlungsroutine, einen Grafikkontext und die umgebende Benutzeroberfläche. Java-Anwendungen können diese Struktur zwar selbst erstellen (z.B. Anwendungen mit grafischer Oberfläche), aber sie erfordern diese nicht (wie Java-Anwendungen erstellt werden, die Applet-ähnliche Grafiken und Benutzeroberflächen enthalten, erfahren Sie am 14. Tag).
Beachten Sie, daß ein einziges Java-Applet sowohl dazu geschrieben sein kann, als Java-Anwendung ausgeführt zu werden als auch als Java-Applet. Obwohl Sie zum Erstellen von Applets und Anwendungen verschiedene Prozeduren und Regeln verwenden, stehen diese Prozeduren und Regeln nicht in Konflikt zueinander. Die für Applets spezifischen Funktionen werden ignoriert, sobald das Programm als Anwendung ausgeführt wird und umgekehrt. Behalten Sie diesen Punkt im Gedächtnis, wenn Sie eigene Anwendungen und Applets erstellen.
Den letzten wesentlichen Unterschied zwischen Java-Applets und Anwendun-gen – vielleicht der größte Unterschied überhaupt – stellt der Satz von Beschränkungen dar, der für Applets aus Sicherheitsgründen eingehalten werden sollte. Da Java-Applets von jeder beliebigen Site im World Wide Web heruntergeladen und auf dem System des Client ausgeführt werden können, sind bestimmte Sicherheitsvorkehrungen getroffen worden, um das Risiko von virusinfizierten Applets bzw. sogenannten Trojanischen Pferden (die freundlich aussehen, aber das System beschädigen können) zu beschränken. Zu diesen für Applets gültigen Beschränkungen zählt:
Alle diese Regeln gelten für Java-Applets, die mit dem Netscape Navigator oder Microsoft Internet Explorer ausgeführt werden. Andere Java-Browser oder Tools ermöglichen eine Konfiguration des Sicherheitslevels. Der Applet-Viewer im JDK bietet z.B. Zugang zu einer Zugriffskontolliste, in der festgelegt werden kann, welche Verzeichnisse ein Applet lesen oder beschreiben darf. Doch als Entwickler von Applets sollten Sie davon ausgehen, daß Ihr Publikum die Applets in einem Browser ablaufen läßt, der die strengsten Regeln für Applets vorsieht. Für Java-Anwendungen gelten diese Beschränkungen nicht.
In Java 1.1 wird dem Web-Benutzer eine Technik angeboten, welche die Zuverlässigkeit eines Applet garantiert und es ermöglicht, ein Applet ohne die oben beschrieben Beschränkungen auf dem System des Benutzers auszuführen. Diese Methode wird noch heute, aber etwas später, erläutert.as
Die Sicherheitsbeschränkungen für Applets werden manchmal scherzhaft auch als »Sandkasten« bezeichnet (weil Applets zwar in einem eingegrenzten Sandkasten spielen dürfen, aber nicht außerhalb).
Neben den aufgeführten Beschränkungen für Applets enthält Java selbst einige Arten von Sicherheits- und Konsistenzprüfungen im Java-Kompiler und -Interpreter. Damit werden alle Java-Programm auf unorthodoxen Gebrauch der Sprache getestet (mehr darüber erfahren Sie am 21. Tag). Die Kombination dieser Sicherheitsbeschränkungen und -funktionen erschwert es einem Applet, dem System des Client Schaden zuzufügen.
Diese Beschränkungen verhindern alle traditionellen Möglichkeiten, mit denen Client-Systeme beschädigt werden, aber dennoch kann niemals hundertprozentig sichergestellt sein, daß ein schlauer Programmierer auch diese Beschränkungen umgeht, die Privatsphäre verletzt, CPU-Ressourcen verwendet oder einfach lästige Prozeduren einbaut. Sun hat im Netz eine große Umfrage gestartet und dazu aufgefordert, die Beschränkungen zu durchbrechen. Dadurch konnten einige Probleme behoben und Lücken geschlossen werden, die sich zumeist auf das Laden von Klassen und die Verbindung zu nicht autorisierten Sites bezogen haben. Am 21. Tag erhalten Sie weitere Informationen zum Thema Sicherheit in Java.
Bis zu diesem Zeitpunkt ist kaum ein Wort zu den Unterschieden zwischen Java 1.02 und 1.1 gefallen. Das soll sich nun ändern. Während der nächsten Woche spielen diese Unterschiede eine große Rolle, denn sie bestimmen wie die Applets geschrieben und verteilt werden.
Java 1.1 wurde wie folgt konzipiert: Wenn Sie keine der neuen Funktionen verwenden und bei der 1.02-API bleiben, werden die Programm weiterhin in einer 1.02-Umgebung ausgeführt. Wenn Sie jedoch Funktionen verwenden, die ausschließlich in Java 1.1 zur Verfügung stehen, läßt sich das Applet oder die Anwendung auch nur in der 1.1-Umgebung ausführen.
Für die Applets bedeutet dies, daß sich die Funktionen aus der Version 1.1 nur in einem Browser ausführen lassen, der die neue Version 1.1 unterstützt. Zum Zeitpunkt der Drucklegung dieses Buches hat Netscape angekündigt, die Version 1.1 im Communicator zu unterstützen, aber diese Version steht aktuell noch nicht zur Verfügung. Weder Netscape 3.0 noch der Microsoft Internet Explorer 3.0 können Applets abspielen, die mit Java-1.1-Funktionen ausgestattet sind.
Wenn Sie beabsichtigen, Funktionen aus Java 1.1 in Ihren Applets zu verwenden, können Sie diese Applets mit dem Applet-Viewer von Sun, der im JDK 1.1 enthalten ist (und der CD-ROM zu diesem Buch beiliegt), testen. Falls mittlerweile bereits ein Browser zur Verfügung steht, der die Version 1.1 unterstützt, verwenden Sie diesen zur Prüfung der Applets.
Behalten Sie jedoch im Gedächtnis, daß im Web selbst die verschiedensten Browser-Arten verwendet werden. Die Verfügbarkeit eines Browsers für die Version 1.1 bedeutet noch nicht, daß jeder Benutzer diesen besitzt. Um auch ältere Browser-Versionen zu berücksichtigen, sollten Sie mehrere Applets (für 1.02 und 1.1) anbieten, die nur jene Applets in Java 1.1 schreiben, welche die neuen Funktionen benötigen und noch eine Weile mit der Oberfläche 1.02 API arbeiten, bis die Version 1.1 richtig Fuß gefaßt hat. Wenn Sie in einem Intranet arbeiten, wo Sie sicher sein können, daß alle Leser über die neue Version verfügen, müssen Sie diese Vorsichtsmaßnahmen nicht treffen.
Die Funktionen der Version 1.1 werden innerhalb dieses Buches besonders hervorgehoben, damit Sie wissen, welche Funktionen sich in der neuen Version unterscheiden. Darüber hinaus haben sich von Version 1.02 zu 1.1 einige Namen für Methoden geändert. Sie können zwar nach wie vor die alten Methoden verwenden, aber bei der Kompilierung der Programme, werden Sie Fehlermeldungen zu diesen Methoden erhalten. Wechseln Sie zur API 1.1; hier werden die Fehlermeldungen nicht angezeigt.
Sun bietet als Bestandteil von JDK ein Skript für die Konvertierung von Programmen an, die im alten API geschrieben sind, um das neue API zu unterstützen. Das Skript ist in UNIX SED geschrieben, d.h. es läßt sich am besten auf UNIX-Systemen ausführen. Wenn Sie unter einer Windows-Umgebung arbeiten, die UNIX-Tools unterstützt, können Sie dieses Skript eventuell ebenfalls verwenden. Das Skript ersetzt einfach die alten Methoden durch die neuen. Es fügt keine neuen Funktionen ein bzw. schreibt die Struktur des Programms nicht neu.
Weitere Informationen zur Konvertierung von Programmen aus der Version 1.02 in die neue Version 1.1 finden Sie unter:
http://www.javasoft.com:80/products/jdk/1.1/docs/guide/awt/HowToUpgrade.html
Bei fast allen Java-Programmen, die Sie in den bisherigen Lektionen geschrieben haben, handelte es sich um Java-Anwendungen -- einfache Programme mit einer main()-Methode-, die Objekte erstellt, Instanzvariablen setzt und Methoden ausführt. Heute und in den nächsten Tagen, erstellen Sie ausschließlich Applets, deshalb müssen Sie zunächst wissen, wie Applets funktionieren, welche Merkmale sie aufweisen, und wo Sie mit dem Erstellen eines Applet beginnen.
Um ein Applet zu erstellen, legen Sie eine Subklasse der Klasse Applet an, die sich im Paket java.applet befindet. Die Applet-Klasse beinhaltet einen Großteil der Verhaltensstrukturen, die ein Applet für die Ausführung in einem Java-Browser benötigt. Ferner ziehen Applets aus dem AWT Nutzen, also allen Elementen von grafischen Benutzeroberflächen: das Erstellen von Fenstern, Menüleisten, Schaltflächen, Kontrollfeldern und anderen UI-Elementen. Auch Ereignisse aus Mausaktionen – und Tastatureingaben – lassen sich hiermit handhaben. Die AWT-Klassen bilden einen Teil des Pakets java.awt.
Das Java Abstract Windowing Toolkit (AWT) sieht Klassen und Eigenschaften zur Erstellung von GUI-Anwendungen in Java vor. Applets verwenden viele dieser Möglichkeiten des AWT.
Obwohl ein Applet beliebig viele Hilfsklassen verwenden kann, löst die Hauptklasse die eigentliche Ausführung des Applet aus. Die Ausgangsklasse hat immer eine Signatur ähnlich der folgenden:
Public class myClass extends java.applet.Applet {
...
}
Beachten Sie das Schlüsselwort public. Java setzt voraus, daß eine Applet-Subklasse public deklariert wird. Das trifft wiederum nur auf die Applet-Hauptklasse zu. Jede von Ihnen angelegte Hilfsklasse kann public oder private sein, oder eine andere Form der Zugriffskontrolle aufweisen, die am 15. Tag beschrieben werden.
Erkennt Java Ihr Applet auf einer Webseite, wird Ihre Applet-Ausgangsklasse und die Hilfsklassen, die diese erste Klasse benutzt, über das Netz geladen und mit dem Bytecode-Interpreter des Browser ausgeführt. Im Gegensatz zu Anwendungen, bei denen Java die main()-Methode direkt in der Ausgangsklasse aufruft, wenn das Applet geladen wird, erstellt Java eine Instanz dieser Klasse und alle systembasierten Methoden werden an diese Instanz geschickt. Mehrere Applets auf der gleichen oder unterschiedlichen Seiten, die die gleiche Klasse benutzen, verwenden andere Instanzen, so daß sich jedes Applet auf dem gleichen System eventuell anders verhält.
Um eine grundlegende Java-Anwendung zu erstellen, muß Ihre Klasse die main()-Methode mit einer spezifischen Signatur haben. Beim Starten der Anwendung wird main() ausgeführt. Sie können von main() aus das Verhalten Ihres Programms festlegen. Applets sind ähnlich, aber komplizierter; sie benötigen die main()-Methode eigentlich überhaupt nicht. Applets können viele verschiedene Aktivitäten umfassen, die verschiedenen wichtigen Ereignissen in seinem Lebenszyklus entsprechen, z.B. Initialisieren, Zeichnen oder Mausereignisse. Jede Aktivität hat eine entsprechende Methode. Das heißt, wenn ein Ereignis stattfindet, ruft der Browser oder ein anderes Java-fähiges Werkzeug diese spezifischen Methoden auf.
Diese Aktivitätsmethoden haben standardmäßig keine Definitionen. Um für solche Ereignisse bestimmte Verhaltensweise vorzusehen, müssen Sie die jeweilige Methode in Ihrer Applet-Subklasse durch erneutes Definieren überschreiben. Sie brauchen selbstverständlich nicht alle zu überschreiben. Unterschiedliches Applet-Verhalten bedeutet, daß jeweils andere Methoden überschrieben werden müssen.
Sie lernen im weiteren Verlauf dieser Woche, wie verschiedene Methoden überschrieben werden. Vorläufig erhalten Sie einen allgemeinen Überblick über die wichtigsten Methoden in einer Applet-Ausführung: Initialisieren, Starten, Stoppen, Zerstören und Anzeigen.
Initialisieren ist der Vorgang, durch den das Applet geladen wird, ähnlich der main()-Methode in Anwendungen. Das Initialisieren von Applets kann das Lesen oder Setzen von Parametern beinhalten, das Erstellen von Hilfsobjekten oder das Laden von Bildern und Schriftarten. Um für die Initialisierung des Applet Verhaltensweisen zu definieren, überschreiben Sie die init()-Methode.
public void init() {
...
}
Nach dem Initialisieren eines Applet wird es gestartet. Das Starten unterscheidet sich vom Initialisieren, denn während seines Lebenszyklus kann ein Applet mehrmals gestartet werden, während die Initialisierung nur einmal stattfindet. Ein Applet kann auch gestartet werden, nachdem es zuvor gestoppt wurde. Ein Applet wird beispielsweise gestoppt, wenn der Benutzer eine Verknüpfung zu einer anderen Seite verfolgt, kehrt er anschließend zur vorherigen Seite zurück, wird das Applet wieder gestartet. Um das Start-Verhalten für ein Applet festzulegen, überschreiben Sie die start()-Methode:
public void start() {
...
}
In die start()-Methode lassen sich Funktionalitäten wie z.B. das Erstellen und Starten eines Thread, das Aussenden der entsprechenden Meldungen an Hilfsobjekte oder irgendeine andere Anweisung zur Ausführung des Startvorgangs unterbringen. Über das Starten von Applets erfahren Sie am 10. Tag noch mehr.
Stoppen und Starten gehen Hand in Hand. Ein Applet wird gestoppt, wenn der Benutzer die Seite mit dem Applet verläßt bzw. wenn das Applet manuell durch den Aufruf der stop()-Methode angehalten wird. Standardmäßig werden alle Threads, die das Applet gestartet haben, weiter ausgeführt. Weitere Informationen zu den Threads erhalten Sie am 10. Tag. Durch Überschreiben von stop() können Sie die Ausführung der Threads unterbrechen und dann neu starten, wenn das Applet wieder angezeigt wird:
public void stop() {
...
}
Zerstören klingt etwas gewalttätig. Durch das Zerstören kann ein Applet hinter sich aufräumen, bevor es oder der Browser beendet wird, z.B. um eventuell laufende Threads zu beenden oder andere laufende Objekte freizugeben. Im allgemeinen brauchen Sie destroy nicht zu überschreiben, sofern Sie nicht bestimmte Ressourcen freigeben müssen, z.B. Threads, die das Applet erzeugt hat. Um einem Applet zu ermöglichen, hinter sich aufzuräumen, überschreiben Sie die destroy()-Methode.
public void destroy() {
...
}
Wodurch unterscheidet sich destroy() von finalize() (siehe 7. Tag)? destroy() ist nur für Applets anwendbar. finalize() ist eine allgemeinere Art für ein einzelnes Objekt eines beliebigen Typs hinter sich aufzuräumen.
Das Zeichnen bestimmt, wie ein Applet Elemente auf dem Bildschirm ausgibt. Dabei kann es sich um Text, eine Linie, farbigen Hintergrund oder ein Bild handeln. Das Zeichnen kann hunderte Male während des Lebenszyklus eines Applet vorkommen (z.B. einmal nach der Initialisierung des Applet, wenn das Browser-Fenster am Bildschirm vorübergehend deaktiviert und dann wieder in den Vordergrund geholt wird oder falls das Browser-Fenster an eine andere Position auf dem Bildschirm versetzt wird oder auch zyklisch im Falle einer Animation). Sie überschreiben die paint()-Methode, um einem Applet das Zeichnen am Bildschirm zu ermöglichen. Die paint()-Methode sieht wie folgt aus:
public void paint(Graphics g) {
...
}
Beachten Sie, daß paint() im Gegensatz zu den anderen hier beschriebenen Methoden ein Argument besitzt: eine Instanz der Klasse Graphics. Dieses Objekt wird vom Browser erstellt und an paint übergeben, weshalb Sie sich darüber keine Gedanken machen müssen. Sie sollten jedoch sicherstellen, daß die Graphics-Klasse (Teil des Pakets java.awt) in den Applet-Code importiert wird. Dies wird zumeist mit der Anweisung import am Anfang der Java-Datei ausgeführt.
import java.awt.Graphics;
Am 2. Tag haben Sie ein einfaches Applet namens HelloAgainApplet erstellt (das mit dem großen, roten Hello Again). Sie haben das Applet als ein Beispiel für das Anlegen einer Subklasse erstellt und verwendet. Wir gehen den Code für dieses Applet noch einmal durch, diesmal allerdings mit dem Blickpunkt auf jene Details, die Sie soeben über Applets gelernt haben. Listing 8.1 enthält den Code für dieses Applet:
Listing 8.1: Das Applet Hello Again
1: import java.awt.Graphics;
2: import java.awt.Font;
3: import java.awt.Color;
4:
5: public class HelloAgainApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8:
9: public void paint(Graphics g) {
10: g.setFont(f);
11: g.setColor(Color.red);
12: g.drawString("Hello again!", 5, 50);
13: }
14: }
Dieses Applet überschreibt paint(), eine der wichtigsten Methoden, die im vorherigen Abschnitt beschrieben wurden. Da das Applet eigentlich nichts besonders ausführt (nur zwei Wörter am Bildschirm ausgibt), und es nichts zu initialisieren gibt, ist start(), stop() oder init() nicht erforderlich.
Die eigentliche Aufgabe dieses Applet (so gering sie auch sein mag), findet bei der paint()-Methode statt. Das an die paint()-Methode übergebene Graphics-Objekt enthält den Grafikstatus, d.h. die aktuellen Merkmale der Zeichnungsoberfläche, wie z.B. die Vorder- und Hintergrundfarben. Die Zeilen 10 und 11 definieren die Standardschrift und -farbe dieses Grafikstatus (das Font-Objekt in der Instanzvariablen f und ein Objekt, das die Farbe Rot darstellt, die aus der Color-Klasse stammt.)
Zeile 12 zeichnet die Zeichenkette Hello Again! in der angegebenen Schrift und Farbe auf Position 5, 50. Der Punkt 0 für y ist die obere linke Ecke der Zeichenfläche des Applet, wobei das positive y nach unten verläuft, so daß 50 die untere Grenze des Applet ist. Abb. 8.1 zeigt, wie das Begrenzungsfeld und die Zeichenkette für das Applet auf der Seite gezeichnet wird.
|
Abbildung 8.1:
|
Wenn Sie den Beispielen bis zu diesem Punkt gefolgt sind, haben Sie eventuell bemerkt, daß in dieser Klasse etwas zu fehlen scheint: eine main()-Methode. Wie bereits im Abschnitt zu den Unterschieden zwischen Applets und Anwendungen erwähnt, müssen Applets nicht über eine main()-Methode verfügen. Wenn Sie die korrekten Applet-Methoden in Ihrer Klasse (init(), start(), stop(), paint() usw.) implementieren, funktioniert das Applet auch ohne expliziten Ausgangspunkt problemlos.
Nachdem Sie eine oder mehrere Klassen erstellt haben, die Ihr Applet enthalten, und wie bei jedem anderen Java-Programm in Klassendateien kompiliert haben, legen Sie mit HTML eine Webseite an, die dieses Applet aufnimmt. Zum Einbinden von Applets auf Webseiten wird ein spezielles HTML-Tag verwendet. Java-fähige Browser verwenden die im Tag enthaltenen Informationen, um die kompilierte Klassendatei zu lokalisieren und das Applet auszuführen. In diesem Abschnitt, erfahren sie, wie sich Java-Applets auf Webseiten einfügen lassen, und wie sie sich für das Web im allgemeinen einrichten lassen.
Im folgenden Abschnitt wird davon ausgegangen, daß Sie zumindest Grundkenntnisse im Schreiben von HTML-Seiten besitzen. Wenn Sie in diesem Bereich Hilfe benötigen, empfiehlt sich das Buch »Webseiten erstellen« aus dem Workshop von Laura Lemay.
Um ein Applet auf einer Webseite einzufügen, verwenden Sie das Tag <Applet>. Dabei handelt es sich um eine spezielle Erweiterung von HTML zum Einbinden von Applets auf Webseiten. Listing 8.2 zeigt ein einfaches Beispiel für eine Webseite mit einem Applet.
Listing 8.2: Eine einfache HTML-Seite.
1: <HTML>
2: <HEAD>
3: <TITLE>This page has an applet on it</TITLE>
4: </HEAD>
5: <BODY>
6: <P>My second Java applet says:
7: <BR><APPLET CODE="HelloAgainApplet.class" WIDTH=200 HEIGHT=50>
8: Hello Again!
9: </APPLET>
10: </BODY>
11: </HTML>
Beachten Sie bei dem Tag <Applet> auf dieser Seite folgende Punkte:
Beachten Sie, daß das Tag <Applet>, ähnlich dem Tag <IMG>, keinen Absatz erzeugt, deshalb sollte es in einem allgemeineren Text-Tag stehen, z.B. <P> oder in einem Überschrift-Tag (<H1>, <H2> usw.).
Mit der Klassendatei und der HTML-Datei, die einen Bezug zu dem Applet enthalten, sollten Sie die HTML-Datei von Ihrer Festplatte in einen Java-fähigen Browser laden. Der Browser zeigt nun die HTML-Datei an, lädt dann Ihre Applet-Klasse und führt diese aus.
Wenn Sie nicht über einen Java-fähigen Browser verfügen, verwenden Sie zum Testen Ihres Applet die Tools, die häufig in der Entwicklungsumgebung angeboten werden. In JDK können Sie die Applets mit dem Applet-Viewer prüfen. Die Webseite, auf der das Applet ausgeführt wird, ist hier zwar nicht zu sehen, aber Sie können dennoch feststellen, ob das Applet in der von Ihnen gewünschten Weise abläuft.
Abb. 8.2 zeigt das Applet Hello Again bei seiner Ausführung in Netscape.
|
Abbildung 8.2:
|
Nachdem Sie über ein Applet und eine HTML-Datei verfügen und sichergestellt ist, daß diese Elemente auf Ihrem lokalen System korrekt ausgeführt werden, können Sie das Applet dem Publikum im World Wide Web allgemein zur Verfügung stellen, so daß jeder mit einem Java-fähigen Browser das Applet anzeigen kann.
Java-Applets werden von einem Web-Server auf die gleiche Weise bedient wie HTML-Dateien, Bilder und andere Medien. Sie benötigen keine spezielle Software, um Java-Applets im Web zur Verfügung zu stellen. Sie müssen Ihren Server nicht einmal konfigurieren, damit dieser Java-Dateien handhaben kann. Falls Sie über einen Web-Server oder Platz auf einem Web-Server verfügen, müssen Sie lediglich Ihre HTML-Dateien und die kompilierten Klassendateien auf diesen Server übertragen.
Wenn Sie keinen Web-Server verwenden, müssen Sie Platz mieten oder selbst einen Server einrichten. (Das Einrichten und Verwalten von Web-Servern sowie andere Aspekte der Web-Veröffentlichung können nicht Gegenstand dieses Buches sein).
Wird das Tag <Applet> einfach mit den Attributen code, width und height versehen, erstellen Sie damit lediglich einen Platz mit der passenden Größe für das Applet, laden dieses und führen es aus. Das Tag <Applet> kann jedoch auch andere Attribute enthalten, die eine bessere Integration des Applet in das allgemeine Design der Webseite ermöglichen.
Die verfügbaren Attribute des Tag <Applet> sind beinahe mit denen des HTML-Tag <IMG> identisch.
Das Attribut align definiert, wie das Applet auf der Seite ausgerichtet wird. Dieses Attribut kann folgende neun Werte enthalten: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM und ABSBOTTOM.
Mit ALIGN=LEFT und ALIGN=RIGHT, wird das Applet am linken bzw. rechten Rand der Seite ausgerichtet und der gesamte nachfolgende Text umfließt das Applet auf der linken oder rechten Seite. Der Text wird bis zum Ende des Applet in diesem Raum plaziert. Alternativ verwenden Sie das Tag <BR> für den Zeilenumbruch zusammen mit dem Attribut CLEAR, um die Textzeile links unterhalb des Applet zu beginnen. Das Attribut CLEAR kann drei Werte enthalten: CLEAR=LEFT beginnt den Text am nächsten, freien linken Rand, CLEAR=RIGHT beginnt den Text am nächsten freien, rechten Rand und CLEAR=ALL beginnt den Text in der nächsten Zeile, in der beide Ränder frei sind.
Im folgenden finden Sie einen Auszug aus einem HTML-Code, der ein Applet am linken Rand ausrichtet, den Text an der Seite des Applet plaziert, diesen am Ende des Absatzes abbricht und den restlichen Text unter dem Applet einfügt.
<P><APPLET CODE="HelloAgainApplet.class" WIDTH=200 HEIGHT=50
ALIGN=LEFT>Hello Again!</APPLET>
To the left of this paragraph is an applet. It's a
simple, unassuming applet, in which a small string is
printed in red type, set in 36 point Times bold.
<BR CLEAR=ALL>
<P>In the next part of the page, we demonstrate how
under certain conditions, styrofoam peanuts can be
used as a healthy snack.
Abb. 8.3 zeigt, wie dieses Applet und der umgebende Text in einem Java-fähigen Browser erscheint.
|
Abbildung 8.3:
|
Kleinere Applets lassen sich in eine einzelne Textzeile einfügen. Dazu können Sie die folgenden sieben Werte von ALIGN verwenden, um die vertikale Ausrichtung des Applet zum Text festzulegen:
Abb. 8.4 zeigt die verschiedenen Ausrichtungsoptionen, wobei die Linie ein Bild und der Pfeil ein kleines Applet darstellen sollen.
|
Abbildung 8.4:
|
Die Attribute HSPACE und VSPACE werden dazu verwendet, den Abstand zwischen einem Applet und dem umliegenden Text in Pixel anzugeben. HSPACE definiert den horizontalen Abstand links und rechts neben dem Applet. VSPACE bestimmt den vertikalen Abstand ober- und unterhalb des Applet. Als Beispiel dafür soll der folgende Auszug aus einem HTML-Code dienen, der einen vertikalen Abstand von 50 und einen horizontalen Abstand von 10 festlegt.
<P><APPLET CODE="HelloAgainApplet.class" WIDTH=300 HEIGHT=200
ALIGN=LEFT VSPACE=50 HSPACE=10>Hello Again!</APPLET>
To the left of this paragraph is an applet. It's a
simple, unassuming applet, in which a small string is
printed in red type, set in 36 point Times bold.
<BR CLEAR=ALL>
<P>In the next part of the page, we demonstrate how
under certain conditions, styrofoam peanuts can be
used as a healthy snack.
Das Ergebnis sieht in einem Java-Browser wie in Abb. 8.5 aus.
|
Abbildung 8.5:
|
Die letzten beiden Attribute für das Tag <Applet> sind CODE und CODEBASE. Anders als die anderen Attribute, wirken sich diese beiden nicht auf das Erscheinungsbild eines Applet aus, sondern sie beziehen sich auf die aktuelle Position der Java-Applet-Datei, damit diese vom Browser gefunden werden kann.
CODE dient zur Bezeichnung des Namens der Klassendatei, in der sich das Applet befindet. Wird CODE allein im Tag <Applet> verwendet, wird nach der Klassendatei in jenem Verzeichnis gesucht, in dem sich die HTML-Datei befindet, die auf das Applet verweist. Beachten Sie, daß die Klassendateinamen die in CODE angegeben werden, die Erweiterung .class haben. Dies ist ein Unterschied zur Eingabe in der Befehlszeile des Interpreters, der diese Erweiterung nicht erfordert.
Wenn Sie die Klassendateien in einem anderen Verzeichnis auf dem Web-Server speichern möchten als die HTML-Dateien, müssen Sie dem Browser mitteilen, wo sich die Klassendateien befinden. Dazu verwenden Sie das Attribut CODEBASE. CODE enthält also lediglich den Namen der Klassendatei, während CODEBASE dazu dient, einen alternativen Pfadnamen anzugeben (eine URL oder eine relative Pfadangabe). Wenn Sie z.B. die Klassendateien in einem Verzeichnis namens Classes gespeichert haben, welches sich im selben Verzeichnis wie die HTML-Dateien befindet, wird CODEBASE wie folgt definiert:
<APPLET CODE="MyClass.class" CODEBASE="classes"
WIDTH=100 HEIGHT=100></APPLET>
Sind alle Klassendateien an einer zentralen Position gespeichert, können Sie auch eine URL in CODEBASE angeben:
<APPLET CODE="MyClass.class" CODEBASE="http://myserver.com/javaclasses"
WIDTH=100 HEIGHT=100></APPLET>
Wenn die Klassendateien in einem ganz anderen Verzeichnis gespeichert wurden, verwenden Sie CODEBASE wie folgt:
<APPLET CODE="MyClass.class" CODEBASE="http://www.joesserver.com/javaclasses"
WIDTH=100 HEIGHT=100></APPLET>
Die Standardmethode zur Plazierung von Applets auf einer Webseite besteht darin, das Tag <Applet> zur Definition der primären Klassendatei des Applet zu verwenden. Ein Java-fähiger Browser lädt das Applet dann herunter und führt es aus. Alle anderen vom Applet benötigten Klassen oder Dateien werden vom Web-Server heruntergeladen.
Das Problem bei der Ausführung von Applets mit dieser Methode ist, daß der Browser für jede einzelne Datei, die das Applet benötigt (das kann eine andere Hilfsklasse, ein Bild, eine Audiodatei, eine Textdatei etc. sein), eine eigene Verbindung zum Server herstellen muß. Da bereits für die Einrichtung der Verbindung selbst einige Zeit notwendig ist, wird der Zeitaufwand für das Laden des Applet und der zugehörigen Dateien durch diese Technik beträchtlich erhöht.
Die Lösung des Problems bietet ein Java-Archiv, d.h. eine JAR-Datei. Ein Java-Archiv ist eine Sammlung von Java-Klassen oder anderen Dateien, die in eine einzige Datei gepackt werden. Durch die Verwendung von Java-Archiven muß der Browser lediglich eine Verbindung zu diesem einen Archiv auf dem Server herstellen. Indem Sie die Anzahl der Dateien reduzieren, die vom Browser heruntergeladen werden müssen, läßt sich das Applet selbst schneller laden und ausführen. Java-Archive können auch komprimiert werden, wodurch sich die Dateigröße verringert und die Ladezeiten zusätzlich verkürzt werden (doch auch die Dekomprimierung durch den Browser kann einige Zeit beanspruchen).
Java 1.1 unterstützt die JAR-Dateien; das JDK enthält ein Tool namens jar, mit dessen Hilfe sich Dateien in Java-Archive packen und wieder daraus entpacken lassen. JAR-Dateien können mit dem Zip-Format komprimiert oder ohne Komprimierung verpackt werden. Der folgende Befehl packt alle Klassendateien und GIF-Bilddateien eines Verzeichnisses in ein einziges Java-Archiv mit dem Namen Animate.jar:
Jar cf Animate.jar *.class *.gif
Das Argument cf definiert zwei Befehlszeilen-Optionen, die sich für die Ausführung des Programmes jar verwenden lassen. Die Option c gibt an, daß eine Java-Archivdatei erstellt werden soll und die Option f legt fest, daß der Name der Archivdatei als nächstes Argument folgt. Wenn Sie jar ohne Argumente ausführen, sehen Sie eine Liste der verfügbaren Optionen.
Nachdem ein Java-Archiv erstellt ist, wird das Attribut ARCHIVES mit dem Tag <Applet> verwendet, um anzugeben, wo sich das Archiv befindet. Sie können Java-Archive in einem Applet-Tag wie folgt benutzen:
<applet code="Animate.class" archives="Animate.jar" width=460 height=160>
</applet>
Dieses Tag gibt an, daß das Archiv Animate.jar Dateien enthält, die vom Applet benötigt werden. Browser und Surf-Tools, die JAR-Dateien unterstützen, suchen dann innerhalb des Archivs nach den für das Applet notwendigen Dateien.
Ein Java-Archiv kann zwar Klassendateien enthalten, aber auch bei der Verwendung des Attributs ARCHIVES muß das CODE verwendet werden. Der Browser muß auch in diesem Fall den Namen der Hauptklassendatei des Applet kennen, um diese laden zu können.
Ehe die Entwickler von Java das Dateiformat JAR einführten, haben sowohl Netscape als auch Microsoft eigene Archivlösungen angeboten. Diese bieten gegenüber den Java-Archiven keine Vorteile, aber sie lassen sich ebenfalls mit Browsern verwenden, die Java 1.1 unterstützen.
Die aktuelle Version des Netscape-Browser unterstützt ZIP-Archive mit dem Attribut ARCHIVE, diese lassen sich jedoch nur für Klassendateien einrichten, nicht für Bilder oder andere vom Applet benötigte Dateien. In Netscape verwenden Sie das Attribute ARCHIVE dazu, den Namen des Archivs anzugeben:
<APPLET CODE="MyApplet.class" ARCHIVE="appletstuff.zip" WIDTH=100 HEIGHT=100>
</APPLET>
Das Archiv selbst ist eine unkomprimierte Zip-Datei. Die üblichen Zip-Dateien, die durch Komprimierung Dateigrößen reduzieren, werden nicht erkannt. Hilfsklassen können sich inner- oder außerhalb der Zip-Datei befinden; der Browser von Netscape sucht an beiden Positionen. Das Attribut ARCHIVE wird von anderen Browsern oder Applet-Viewern ignoriert.
Der Microsoft Internet Explorer erkennt einen dritten Typ von Archivformaten für Java-Applets: die CAB-Datei. CAB ist die Abkürzung für Cabinet und bietet eine Möglichkeit, Dateien zusammenzufassen und für eine schnellere Übertragung im Web zu komprimieren.
Cabinet-Archive werden mit einem Tool von Microsoft erstellt, welches CABarc heißt. Es steht aktuell zum Herunterladen unter folgender Adresse zur Verfügung:
http://www.microsoft.com/workshop/java/cab-f.htm
Mit CABarc können Sie alle Klassendateien und alle anderen für das Applet erforderlichen Dateien in einem einzigen Archiv komprimieren. Dieses Archiv hat die Dateierweiterung .CAB. Um das Archiv anzugeben, wird der Parameter cabbase zusammen mit dem Tag <PARAM> in HTML verwendet. Der Wert von cabbase ist gleich dem Namen der .CAB-Datei. Hier ein Beispiel:
<APPLET CODE="DanceFever.class" WIDTH=200 HEIGHT=450>
<PARAM NAME="cabbase" VALUE="DanceFever.cab">
</APPLET>
Ebenso wie das Attribut ARCHIVE wird der Parameter cabbase von Web-Browsern ignoriert, die diesen nicht unterstützen.
Die Archivfunktionen von Netscape und Microsoft wurden vor der Herausgabe der Version Java 1.1 eingeführt, deshalb funktionieren sie mit den aktuellen Versionen dieser Browser und eventuell anderen Browsern. Wenn Sie eine dieser Lösungen bevorzugen, sollten Sie beide Archivformen und einen Satz der einzelnen Dateien auf Ihrem Web-Server abspeichern. Auf diese Weise können alle Java-fähigen Browser das Applet verwenden.
Die Strategie für Sicherheit von Java-Applets geht davon aus, daß Sie niemandem im World Wide Web trauen können. Diese Denkweise mag zynisch klingen, in der Praxis bedeutet sie folgendes: Potentiell kann jeder ein Java-Applet erstellen, das Schaden anrichtet, der Benutzer hat keine Chance sich dagegen zu wehren. Deshalb wurden von Anfang an alle Funktionen der Sprache, die einen Mißbrauch ermöglichen, zur Verwendung bei Applets ausgeschlossen.
Java 1.1 bietet eine Möglichkeit an, wie sich alle Funktionen, die für Java-Anwendungen zur Verfügung stehen, auch für Applets einsetzen lassen, sofern sie von einem zuverlässigen Applet-Hersteller stammen und eine digitale Signatur enthalten, welche die Authentizität bestätigen. Eine digitale Signatur ist eine verschlüsselte Datei, die ein Programm begleitet und genau angibt, woher das Programm stammt. Benutzer, die wissen, wer ein Programm hergestellt hat, können dann selbst darüber entscheiden, ob sie dieser Firma oder dem einzelnen Hersteller vertrauen. Wer bereits mit ActiveX-Steuerelementen vertraut ist, kennt dieses System, mit dem auch ActiveX-Steuerelemente auf Seiten im World Wide Web zur Verfügung gestellt werden.
In den künftigen Versionen von JDK sollen verschiedene Sicherheitslevel von kompletter Vertrauenswürdigkeit bis absoluter Unsicherheit (ein Applet kann gegebenenfalls Schaden anrichten) eingerichtet werden.
Doch im Augenblick unterliegen die Applets noch allen Beschränkungen, es sei denn ein Benutzer definiert manuell, daß ein bestimmter Programmierer vertrauenswürdig ist.
Bisher unterstützt keiner der allgemein verfügbaren Web-Browser das neue Sicherheitssystem von JDK 1.1, deshalb befindet sich das Verfahren zur Kennzeichnung und zum Anbieten sicherer Applets noch in den Anfängen seiner Entwicklung. Dieser Abschnitt basiert auf Tools, die augenblicklich zur Verfügung stehen und auf der Dokumentation von JavaSoft, in der die Verfahrensweise beschrieben wird.
Um das Prozedere für eine sichere Applet-Übertragung besser zu verstehen, soll für dieses Beispiel folgendes Szenario gelten: Der Entwickler des Applet heißt Fishhead Software, es gibt eine unabhängige Java-Gruppe namens Signatures ‚R‘ US und einen Web-Benutzer namens Gilbert.
Fishhead Software bietet auf seiner Web Site ein Applet-Spiel an, das höchste Punktzahlen und andere Informationen auf die Festplatte des Benutzers schreibt. Dies ist normalerweise nicht möglich, weil die Applet-Beschränkungen einen Zugriff auf die Festplatte des Benutzers ausschließen. Damit das Spiel dennoch gespielt werden kann, muß Fishhead Software das Applet mit einer digitalen Signatur versehen. Auf diese Weise können die Benutzer Fishhead Software als vertrauenswürdigen Software-Hersteller identifizieren.
Dieser Vorgang wird in fünf Schritten ausgeführt:
1. Fishhead Software verwendet javakey, ein Tool aus JDK, welches zwei verschlüsselte Dateien erstellt, die öffentlicher Schlüssel und privater Schlüssel heißen. Zusammen bilden beide Schlüssel eine elektronische »ID-Karte«, mit deren Hilfe sich der Hersteller komplett identifizieren läßt. Fishhead Software stellt sicher, daß niemand anders auf den privaten Schlüssel Zugriff erhält. Der öffentliche Schlüssel kann und sollte jedem als Teil der ID zugänglich gemacht werden.
Damit hat Fishhead Software das Spiel in einer Weise zur Verfügung gestellt, die es den Benutzern ermöglicht, seine Sicherheitsbedenken auszuräumen. Eine dieser Personen, die sich dazu entschlossen haben, das Applet-Spiel von Fishhead zu laden, ist der Web-Benutzer Gilbert. Er arbeitet mit einem Browser, der Java 1.1 unterstützt.
Seine Aktionen sind einfacher:
1. Gilbert erkennt, daß das neue Applet-Spiel von Fishhead Risiken birgt und er möchte zunächst wissen, ob es sich bei dem Hersteller um eine vertrauenswürdige Firma handelt. Er lädt den öffentlichen Schlüssel von Fishhead herunter.
Öffentlicher und privater Schlüssel ergeben zusammen ein Sicherheitssystem. Da nur beide zusammen Fishhead Software ganz identifizieren, sind beide Schlüssel nur der Firma selbst zugänglich, andernfalls könnte sich jemand anders als Fishhead ausgeben und niemand könnte dies enthüllen. Indem Fishhead seinen privaten Schlüssel schützt, schützt es seine Identität und seine Reputation.
Die Prüfung, die Signatures ,R‘ US unter Verwendung des öffentlichen Schlüssels durchführt, stellt vor allem sicher, daß der öffentliche Schlüssel wirklich zu dieser Firma gehört. Da der öffentliche Schlüssel an jeden weitergegeben werden kann, stellt Fishhead diesen auf der Web Site zur Verfügung. Als Teil des Zertifizierungsvorgangs kann Signatures ,R‘ US diesen herunterladen und mit jenem vergleichen, den es erhalten hat. Die Zertifizierungsgruppe agiert als eine Art Ersatz für den privaten Schlüssel und stellt sicher, daß der öffentliche Schlüssel legitim ist. Das herausgegebene Zertifikat ist mit dem öffentlichen Schlüssel verbunden, der nur zusammen mit dem privaten Schlüssel von Fishhead verwendet werden kann.
Jeder, der mit dem Tool javakey arbeitet, kann ein Zertifikat für einen öffentlichen Schlüssel herausgeben. Fishhead könnte sich das Zertifikat auch selbst ausstellen. Doch mit einem solchen Schritt würde die Glaubwürdigkeit deutlich herabgesetzt. Eine bekannte, unabhängige Zertifizierungsgruppe sorgt für Vertrauenswürdigkeit.
Alle Elemente zusammen bilden eine verläßliche digitale Signatur für ein Java-Archiv. Die JavaSoft-Dokumentation zu javakey, der Applet-Kennzeichnung jar und andere neue Sicherheitsfunktionen stehen unter folgender Web-Adresse zur Verfügung:
http://www.javasoft.com/products/JDK/1.1/docs/guide/security
Bei Java-Anwendungen können Sie Parameter an die main()-Routine weitergeben, indem Sie in der Befehlszeile Argumente verwenden. Sie können diese Argumente dann innerhalb des Körpers der Klasse analysieren lassen, damit sich die Anwendung entsprechend der definierten Argumente verhält.
Applets verfügen jedoch nicht über eine Befehlszeile. Wie lassen sich verschiedene Argumente an ein Applet weiterleiten? Applets können von der HTML-Datei, die das Tag <Applet> enthält, durch Verwendung von Applet-Parametern verschiedene Eingaben erhalten. Um die Parameter in einem Applet einzurichten und zu handhaben, benötigen Sie folgende Elemente:
Applet-Parameter bestehen aus folgenden zwei Teilen: dem Parameternamen, der eine von Ihnen gewählte Bezeichnung ist und dem Wert, welcher dem tatsächlichen Wert dieses speziellen Parameters entspricht. Sie können also beispielsweise die Farbe des Textes in einem Applet definieren, indem Sie einen Parameter mit dem Farbnamen und dem Wert red (rot) angeben. Oder Sie legen die Geschwindigkeit einer Animation fest, indem Sie einen Parameter mit dem Namen Speed und einen Wert von 5 verwenden.
In der HTML-Datei, die das eingebettete Applet enthält, fügen Sie Parameter mit dem Tag <PARAM> ein. Dieses Tag verfügt über zwei Attribute für den Namen und den Wert, diese haben die Bezeichnung Name und Value. Das Tag <PARAM> befindet sich innerhalb der Tags <Applet> und </Applet>:
<APPLET CODE="MyApplet.class" WIDTH=100 HEIGHT=100>
<PARAM NAME=font VALUE="TimesRoman">
<PARAM NAME=size VALUE="36">
A Java applet appears here.</APPLET>
In diesem Beispiel werden zwei Parameter für das Applet MyApplet bestimmt: font mit dem Wert TimesRoman und size mit dem Wert 36.
Diese Parameter werden beim Laden des Applet weitergeleitet. In der init()-Methode des Applet können Sie diese Parameter mit der getParameter()-Methode berücksichtigen. getParameter() nimmt ein Argument an – eine Zeichenkette, die den Namen des Parameters bezeichnet, nach dem Sie suchen. Dann gibt die Methode eine Zeichenkette mit dem entsprechenden Wert aus. (Wie bei Argumenten in Java-Anwendungen werden alle Parameterwerte in Zeichenketten konvertiert.) Um den Wert des font-Parameters aus der HTML-Datei zu erhalten, können Sie z.B. die folgende Zeile in die init()-Methode aufnehmen:
String theFontName = getParameter("font");
Die Namen der in <PARAM> angegebenen Parameter und die Namen der Parameter in getParameter müssen absolut identisch sein, auch in bezug auf Groß- und Kleinschreibung. Mit anderen Worten: <PARAM=NAME=-"name"> unterscheidet sich von <PARAM=NAME="Name">. Werden Ihre Parameter nicht richtig an das Applet weitergeleitet, überprüfen Sie die Parameternamen.
Falls ein erwarteter Parameter nicht in der HTML-Datei angegeben wurde, gibt getParameter Null aus. In den meisten Fällen wird auf einen null-Parameter getestet und ein vernünftiger Standardwert ausgegeben.
if (theFontName == null)
theFontName = "Courier"
Da getParameter Zeichenketten ausgibt, müssen Sie außerdem konvertieren, falls ein Parameter ein anderes Objekt oder ein anderer Typ sein soll. Um den Parameter size aus der gleichen HTML-Datei zu analysieren und ihm eine Ganzzahlvariable namens theSize zuzuweisen, können Sie folgende Zeilen schreiben:
int theSize;
String s = getParameter("size");
if (s == null)
theSize = 12;
else theSize = Integer.parseInt(s);
Noch nicht ganz klar? Dann wollen wir ein Beispiel für ein Applet schreiben, das diese Technik verwendet. Sie modifizieren HelloAgainApplet dahingehend, daß es Hello mit einem bestimmten Namen ausgibt, z.B. »Hello Bill« oder »Hello Alice«. Der Name wird über einen HTML-Parameter an das Applet weitergeleitet.
Kopieren Sie dazu die ursprünglichen HelloAgainApplet-Klasse und nennen Sie diese MoreHelloAgain, wie in Listing 8.3 dargestellt:
Listing 8.3: Das Applet MoreHelloAgain.
1:import java.awt.Graphics;
2:import java.awt.Font;
3:import java.awt.Color;
4:
5:public class MoreHelloApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8:
9: public void paint(Graphics g) {
10: g.setFont(f);
11: g.setColor(Color.red);
12: g.drawString("Hello Again!", 5, 40);
13: }
14:}
Als erstes müssen Sie in dieser Klasse Platz für den Namen einfügen. Da dieser Name im gesamten Applet benötigt wird, verwenden wir eine Instanzvariable unmittelbar nach der Variablen für den Font:
String name;
Um für den Namen einen Wert zu setzen, müssen Sie den Parameter aus der HTML-Datei holen. Die beste Stelle für Applet-Parameter befindet sich innerhalb einer init()-Methode. Die init()-Methode wird ähnlich definiert wie paint() (public, ohne Argumente und void als Rückgabetyp). Achten Sie darauf, daß Sie Parameter auch auf einen null-Wert testen. Wird kein Name angegeben, ist der Standard in diesem Fall »Laura«. Fügen Sie die init()-Methode zwischen die Definition der Instanzvariablen und die Definition für paint() ein, also vor Zeile 9:
public void init() {
name = getParameter("name");
if (name == null)
name = "Laura";
}
Zum Schluß müssen Sie den Namen noch ändern, damit eine komplette Zeichenkette entsteht, d.h. Hello mit einem Leerzeichen versehen und ein Ausrufezeichen an das Ende setzen. Diese Änderungen könnten Sie in der paint()-Methode vornehmen, unmittelbar vor der Ausgabe der Zeichenkette am Bildschirm. Damit müßte allerdings jedesmal eine neue Zeichenfolge erstellt werden, wenn das Applet gezeichnet wird. Es wäre effizienter, dies nur einmal durchzuführen und zwar in der init()-Methode, direkt nach dem Namen selbst. Fügen Sie die folgende Zeile in die init()-Methode direkt vor der letzten Klammer ein:
name = "Hello " + name + "!";
Nun muß nur noch die paint()-Methode geändert werden, damit der neue Parametername verwendet wird. Die ursprüngliche sieht wie folgt aus:
g.drawString("Hello Again!", 5, 40);
Um die neue Zeichenkette, die Sie in der Instanzvariablen name gespeichert haben, zu zeichnen, müssen Sie nur die Variable für die Literal-Zeichenkette ändern:
g.drawString(name, 5, 40);
Listing 8.4 zeigt das endgültige Ergebnis der Klasse MoreHelloApplet. Kompilieren Sie es, um eine komplette Klassendatei zu erhalten.
Listing 8.4: Die MoreHelloApplet-Klasse.
1: import java.awt.Graphics;
2: import java.awt.Font;
3: import java.awt.Color;
4:
5: public class MoreHelloApplet extends java.applet.Applet {
6:
7: Font f = new Font("TimesRoman", Font.BOLD, 36);
8: String name;
9:
10: public void init() {
11: name = getParameter("name");
12: if (name == null)
13: name = "Laura";
14:
15: name = "Hello " + name + "!";
16: }
17:
18: public void paint(Graphics g) {
19: g.setFont(f);
20: g.setColor(Color.red);
21: g.drawString(name, 5, 40);
22: }
23: }
Nun erstellen wir eine HTML-Datei, die dieses Applet enthält. Listing 8.5 zeigt eine neue Webseite für das MoreHelloApplet-Applet.
Listing 8.5: Die HTML-Datei für das Applet MoreHelloApplet.
1: <HTML>
2: <HEAD>
3: <TITLE>Hello!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="MoreHelloApplet.class" WIDTH=200 HEIGHT=50>
8: <PARAM NAME=name VALUE="Bonzo">
9: Hello to whoever you are!
10: </APPLET>
11: </BODY>
12: </HTML>
Beachten Sie, daß das Tag <Applet>, welches auf die Klassendatei für das Applet verweist, die passende Breite und Höhe (200 und 50) angibt. Unmittelbar darunter (in Zeile 8) steht das Tag <PARAM>, welches zur Weitergabe an den Namen verwendet wird. Hier ist der NAME-Parameter einfach name und der Wert ist "Bonzo".
Wenn Sie diese HTML-Datei in den Netscape Navigator laden, erscheint das Ergebnis aus Abb. 8.6.
|
Abbildung 8.6:
|
Lassen Sie uns ein weiteres Beispiel ausprobieren. Wie Sie wissen, wird standardmäßig der Name Laura ausgegeben, wenn im Code für MoreHelloApplet kein Name spezifiziert wird. Mit dem Code aus Listing 8.6 wird eine HTML-Datei ohne Parameter-Tag für den Namen verwendet.
Listing 8.6: Weitere HTML-Datei für das Applet MoreHelloApplet.
1: <HTML>
2: <HEAD>
3: <TITLE>Hello!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="MoreHelloApplet.class" WIDTH=200 HEIGHT=50>
8: Hello to whoever you are!
9: </APPLET>
10: </BODY>
11: </HTML>
Da hier kein Name angegeben ist, verwendet das Applet den Standard und das Ergebnis erscheint wie in Abb. 8.7 dargestellt.
|
Abbildung 8.7:
|
Die Sprache Java wird heutzutage sicherlich überwiegend für Applets verwendet. Applet sind komplizierter als viele Java-Anwendungen, weil Sie innerhalb von Webseiten ausgeführt und gezeichnet werden. Sie bieten aber einfachen Zugang zu Grafiken, Benutzeroberflächen und Ereignisstrukturen, die vom Browser selbst vorgesehen sind. Sie haben heute die folgenden Grundlagen für das Erstellen von Applets kennengelernt:
F Wenn ich keine Dateien lesen und schreiben oder Programmen auf den Systemen ausführen kann, auf denen das Applet verwendet wird, dann bedeutet dies doch im Grunde, daß ich außer einfachen Animationen oder poppigen Grafiken nichts machen kann? Wie kann ich Zustände in einem Applet speichern? Wie kann ich z.B. eine Textverarbeitung oder Tabellenkalkulation als Java-Applet erstellen?
A Während die einen die Sicherheitsbeschränkungen von Java schätzen, sind andere aus dem gleichen Grund überzeugt, daß die Fähigkeiten der Sprache dadurch eingeschränkt werden. Java-Applets sind gerade wegen dieser Sicherheitsvorkehrungen begrenzt. Doch angesichts der zahlreichen Möglichkeiten eines Mißbrauchs finde ich, daß es besser ist, der Sicherheit vor der Programmiervielfalt den Vorzug zu geben.
Durch die digitale Signatur für Applets, können auf Webseiten auch raffiniertere Funktionen angeboten werden, die vor der Version 1.1 nicht zur Verfügung standen. Grundlage dafür ist jedoch, daß der Benutzer dem Applet-Hersteller traut und es wird sich erst mit der Zeit herausstellen, wie effektiv dieses Sicherheitssystem wirklich ist, und ob die große Kluft zwischen der Sicherheit der Benutzersysteme und dem Wunsch nach komplett ausgestatteten Applets damit überbrückt werden kann.
F Ich habe in meiner Dokumentation gelesen, daß das Tag <Applet> auch über ein Attribut Name verfügt. Warum ist das hier nicht erläutert worden?
A Name wird benutzt, wenn sich auf einer Seite mehrere Applets befinden, die miteinander kommunizieren. Nähere Informationen zu diesem Thema erhalten Sie am 12. Tag.
F Viele Applets, die ich im Web gesehen habe, verwenden die init()-Methode nur dazu, um die resize()-Methode aufzurufen, welche dieselben Werte für WIDTH und HEIGHT enthält wie das Tag <Applet>. Ein Freund hat mir gesagt, daß resize() unbedingt verwendet werden muß, um sicherzustellen, daß das Applet die richtige Größe hat. Warum haben Sie resize() nicht erwähnt?
A Der Aufruf der resize()-Methode innerhalb von init() stammt noch aus den Anfangstagen der Applets. Zu diesem Zeitpunkt wurde resize() noch dazu benötigt, die Anfangsgröße des Applet zu definieren. Heute übernehmen die Attribute WIDTH und HEIGHT diese Aufgabe. Der Aufruf von resize() ist nicht mehr notwendig.
F Ich verwende Netscape 2.0 unter Windows und kann Text nicht neben einem Applet plazieren, wie Sie diese im Abschnitt zu ALIGN beschrieben haben. Was mache ich falsch?
A Nichts. Netscape 2.0 unter Windows hat einen Fehler, der verhindert, daß ALIGN unter Windows korrekt ausgeführt wird. Steigen Sie auf die Version 3.0 des Net-scape Navigator um oder eine höhere Version, dann ist das Problem behoben.
F Ich habe ein Applet, das Parameter holt und eine HTML-Datei, die diese Parameter weitergibt. Beim Ausführen meines Applet erhalte ich aber nur Nullwerte. Woran liegt das?
A Stimmen die Namen der Parameter (im NAME-Attribut) genau mit denen überein, die Sie zum Prüfen von getParameter verwenden? Sie müssen absolut übereinstimmen, auch hinsichtlich der Groß- und Kleinschreibung. Achten Sie darauf, daß Ihre <PARAM>-Tags innerhalb von öffnenden und schließenden <Applet>-Tags stehen und daß kein Name falsch geschrieben wurde.
F Wie kann ich, da Applets nicht über eine Befehlszeile verfügen, eine einfache Debugging-Ausgabe wie System.out.print1n() in einem Applet vornehmen?
A Dies ist trotzdem möglich. Je nach Browser oder Java-fähiger Umgebung, verfügen Sie über ein Konsolenfenster, in dem die Debugging-Ausgabe (wie System.out.print1n()) erscheint oder sie wird in einer Log-Datei gespeichert (Netscape verfügt im Menü Optionen über eine Java-Konsole, der Internet Explorer verwendet eine Java-Log-Datei, die durch Optionen/Erweitert aktivieren können). Sie können in den Applets weiterhin Meldungen mit System.out.print1n() ausgeben, sollten diese aber anschließend entfernen, damit sie den Leser nicht verwirren!
(c) 1997 SAMS
