Java wurde vor allem deshalb so beliebt, weil es die Möglichkeit bietet, daß Java-fähige Web-Browser Java-Applets unterstützen - kleine Routinen, die auf einer Web-Seite ausgeführt werden, um dynamische, interaktive Web-Seiten zu entwickeln. Applets werden, wie bereits erwähnt, in Java geschrieben, und Sie können sie in jedem Browser ansehen, der Java unterstützt, unter anderem HotJava von Sun, Netscape Navigator und Microsoft Internet Explorer. Dieses Buch will Ihnen vor allem zeigen, wie Sie Applets entwickeln.
Java unterstützt auch die Entwicklung von Standalone-Programmen, den sogenannten Anwendungen. In den letzten Kapiteln haben Sie die Sprache Java kennengelernt und die meisten der kleinen Programme, die Sie dort erstellt haben, waren Java-Anwendungen, die jedoch nur Ausgaben auf den Bildschirm vorgenommen haben. Nachdem Sie jetzt die Grundlagen besitzen, erfahren Sie mehr über Anwendungen, auch mit grafischen Benutzeroberflächen.
Die JBuilder-IDE stellt Applet- und Anwendungs-Experten bereit, die Code-Gerüste für Ihre Java-Programme erzeugen. Sie werden erfahren, was diese Experten für Sie tun und welche Information sie brauchen, um ihren Zauber wirken zu lassen.
Heute werden Sie sehr viel lernen:
Um ein neues Projekt für die heutigen Listings zu erzeugen, wählen Sie Datei | Neues Projekt und geben in das Datei-Feld folgendes ein:
C:\JBUILDER\myprojects\AppletsAppsWizards.jpr
Klicken Sie auf die Schaltfläche Fertigstellen. Alle heute erzeugten Listings werden diesem Projekt durch das Icon Dem Projekt hinzufügen, das sich über dem Navigations-Bereich im AppBrowser befindet, hinzugefügt.
Sie haben zwar die Unterschiede zwischen Java-Anwendungen und Java-Applets bereits kennengelernt, aber wir wollen sie hier noch einmal wiederholen.
Kurz gesagt, Java-Anwendungen sind Standalone-Java-Programme, die unter Verwendung des Java-Interpreters von der Befehlszeile aus oder im JBuilder ausgeführt werden können.
Java-Applets dagegen können nicht unabhängig ausgeführt werden, sie brauchen dazu einen Web-Browser. Mit einem speziellen HTML-Tag-Paar wird ein Applet in eine Web-Seite eingebettet. Wenn ein Java-fähiger Browser eine Web-Seite mit einem Applet lädt, lädt er den Code des Applets vom Web-Server herunter und führt ihn auf dem lokalen System aus (auf dem auch der Browser läuft).
Weil Java-Applets in einem Java-fähigen Web-Browser laufen, nutzen sie den Vorteil der Struktur, die dieser bereitstellt: ein existierendes Fenster, eine Ereignisverarbeitung und einen Grafikkontext sowie die zugrunde liegende Benutzeroberfläche. Java-Anwendungen können diese Struktur auch erzeugen, aber sie brauchen sie nicht.
Die Bequemlichkeit, die Applets gegenüber Anwendungen hinsichtlich der Struktur und der Benutzeroberfläche haben, wird jedoch durch die Einschränkungen aufgewogen, denen die Applets unterliegen. Weil Java-Applets von irgendeinem Server heruntergeladen und auf dem System eines Clients ausgeführt werden, sind diese Einschränkungen erforderlich, um Applets daran zu hindern, das System zu beschädigen oder die Sicherheit zu gefährden. Ohne diese Einschränkungen könnten Java-Applets Viren oder Trojanische Pferde (Programme, die friedlich scheinen, in Wirklichkeit aber das System zerstören) enthalten, oder sie könnten einen Angriff auf die Sicherheit des ausführenden Systems vornehmen. Applets unterliegen unter anderem den folgenden Einschränkungen:
Darüber hinaus beinhaltet Java selbst verschiedene Formen von Sicherheits- und Konsistenzprüfungen im Java-Compiler und im Interpreter, um eine illegale Verwendung der Sprache zu verhindern. Diese Kombination aus Einschränkungen und Sicherheitsmaßnahmen macht es einem feindseligen Java-Applet schwer, das System des Clients zu gefährden.
Die Java-Programme, die Sie bisher erstellt haben, waren größtenteils Java-Anwendungen - einfache Programme mit einer einzigen main()-Methode, die Objekte erzeugte, Instanzvariablen setzte und Methoden ausführte. Heute und in den folgenden Lektionen werden Sie nur noch Applets erzeugen, Sie müssen also wissen, wie ein Applet funktioniert, und wo Sie bei der Entwicklung eines Applets beginnen. Packen wir's an!
Um ein Applet zu erzeugen, erstellen Sie eine Unterklasse der Klasse Applet, einem Eleme public class myAppletClass extends java.applet.Applet {...}
Beachten Sie das Schlüsselwort public. In Java muß Ihre Applet-Unterklasse als public deklariert werden.
Das ist sinnvoll, weil ja das Applet von der allgemeinen Öffentlichkeit im Internet ausgeführt werden soll.
Auch das gilt aber nur für Ihre Haupt-Applet-Klasse. Alle Hilfsklassen, die Sie anlegen, können je nach
Bedarf public oder private sein.
Wenn ein Java-fähiger Web-Browser auf einer Web-Seite auf Ihr Applet trifft, lädt er Ihre Applet-Klasse
über Ihre Internet-Verbindung (Modem, T1, LAN usw.), ebenso wie alle Hilfsklassen, die für diese erste
Klasse erforderlich sind. Bei Anwendungen ruft Java für Ihre erste Klasse direkt die main()-Methode auf.
Wird dagegen ein Applet geladen, erzeugt Java eine Instanz dieser Klasse, und für diese Instanz werden
diverse Applet-Methoden aufgerufen. Verschiedene Applets, die dieselbe Klasse verwenden, verwenden
unterschiedliche Instanzen, so daß sie sich anders verhalten können als andere Applets, die im selben
Web-Browser ausgeführt werden.
Um eine grundlegende Java-Anwendung zu erzeugen, braucht Ihre Klasse die Methode, main(), mit einer
spezifischen Signatur. Wenn Ihre Anwendung gestartet wird, wird main() ausgeführt, und von main() aus
können Sie das Verhalten einrichten, das Ihr Programm braucht. Applets sind ähnlich, aber komplizierter.
Applets beinhalten viele verschiedene Aktivitäten, die den wichtigsten Ereignissen in ihrem Lebenszyklus
entsprechen - z.B. Initialisierung, Zeichnen oder Mausereignisse. Für jede Aktivität gibt es eine
entsprechende Methode; wenn ein Ereignis auftritt, ruft der Browser oder ein anderes Java-fähiges
Werkzeug diese spezifischen Methoden auf.
Die Standardimplementierungen dieser Methoden tun noch nichts; um das Verhalten für ein Ereignis
bereitzustellen, müssen Sie die jeweilige Methode in der Unterklasse des Applets zur Verfügung stellen. Sie
müssen natürlich nicht alle überschreiben - verschiedene Applets brauchen verschiedene Methoden, die sie
dann überschreiben können.
Mehr über die Methoden erfahren Sie im Laufe der Woche, aber um Ihnen einen allgemeinen Überblick zu
verschaffen, sind im folgenden fünf der wichtigsten Methoden bei der Ausführung eines Applets aufgelistet:
Initialisierung, Starten, Unterbrechen, Zerstören und Zeichnen.
Die Initialisierung erfolgt beim Laden des Applets. Zur Initialisierung zählen das Erzeugen der Objekte, die
das Applet benötigt, die Einrichtung eines Ausgangsstatus, das Laden von Bildern oder Schriften oder das
Setzen von Parametern. Um das Verhalten für die Initialisierung Ihres Applets bereitzustellen, überschreiben
Sie die init()-Methode:
Nachdem ein Applet initialisiert ist, wird es gestartet. Das Starten kann auch erfolgen, wenn das Applet
zuvor unterbrochen aber nicht zerstört wurde. Beispielsweise wird ein Applet unterbrochen, wenn der Leser
einen Link auf eine andere Seite verfolgt, und es wird neu gestartet, wenn der Leser auf seine Seite
zurückkehrt. Beachten Sie, daß das Starten (und Unterbrechen) mehreren Male im Lebenszyklus eines
Applets auftreten kann, während die Initialisierung nur einmal passiert. Um das Startverhalten für Ihr Applet
bereitzustellen, überschreiben Sie die start()-Methode:
Funktionalität, die Sie in die start()-Methode einbinden könnten, ist das Starten eines Threads zur Steuerung
des Applets, das Senden der entsprechenden Nachrichten an die Hilfs-Objekte oder eine Möglichkeit, dem
Applet mitzuteilen, daß es jetzt ausgeführt werden soll. Mehr über das Starten von Applets erfahren Sie
morgen.
Unterbrechen und Starten gehen oft Hand in Hand. Das Unterbrechen erfolgt, wenn der Leser die Seite
verläßt, die ein aktuell laufendes Applet enthält, oder indem die Methode stop() aufgerufen wird.
Standardmäßig läuft der Thread, mit dem das Applet gestartet wurde, weiter, wenn der Leser die Seite
verläßt. Durch Überschreiben von stop() können Sie die Ausführung dieser Threads unterbrechen und sie
neustarten, wenn das Applet wieder geladen wird. (
Das Zerstören hört sich gewalttätiger an als es ist. Beim Zerstören wird es dem Applet ermöglicht,
aufzuräumen, bevor es freigegeben wird, oder bevor der Web-Browser beendet wird - um beispielsweise
alle laufenden Threads zu beenden oder andere laufende Objekte freizugeben. Im allgemeinen will man
destroy() nicht überschreiben, es sei denn, Sie wollen eine ganz bestimmte Ressource freigeben -
beispielsweise Threads, die das Applet erzeugt hat. Um das Aufräumen für Ihr Applet bereitzustellen,
überschreiben Sie die destroy()-Methode:
Beim Zeichnen gibt das Applet etwas auf den Bildschirm aus, sei es Text, eine Linie, ein farbiger
Hintergrund oder ein Bild. Das Zeichnen kann hunderte von Malen im Lebenszyklus eines Applets auftreten
- beispielsweise, wenn es gestartet wird, wenn der Browser durch ein anderes Fenster auf dem Bildschirm
überdeckt wurde und dann wieder angezeigt wird, oder wenn eine Animation dargestellt werden soll. Die
paint()-Methode wird überschrieben, damit Sie eine visuelle Darstellung auf dem Bildschirm erhalten. Die
paint()-Methode sieht wie folgt aus:
public void paint(Graphics g) {...}
Anders als die anderen wichtigen Methoden in diesem Abschnitt nimmt paint() ein Argument entgegen, eine
Instanz der Klasse Graphics. Dieses Objekt wird vom Browser erzeugt und paint() übergeben, Sie müssen
sich also keine Gedanken darüber machen. Allerdings müssen Sie sicherstellen, daß Ihr Applet-Code die
Klasse Graphics importiert (sie ist Teil des Paktes java.awt) :
Weil Ihr Applet ohne Überschreiben von paint() auf der HTML-Seite nicht sichtbar ist, ist diese
import-Zeile lebenswichtig für den Quellcode jedes Applets.
In Kapitel 3 haben Sie das einfache Applet HelloAgainApplet erzeugt (das den Text Hello Again! in roten
Buchstaben ausgab). Dort haben Sie dieses Applet als Beispiel zum Erzeugen einer Unterklasse
herangezogen. Nun wollen wir den Code noch einmal betrachten, jetzt unter dem Namen
HelloAgainApplet2, werden es aber hier in einem anderen Licht betrachten. Listing 8.1 zeigt den Code für
dieses Applet.
Listing 8.1: HelloAgainApplet2.java
1: import java.applet.*; Dieses Applet überschreibt die paint()-Methode. Weil es nicht sehr viel macht, außer zwei Worte auf den
Bildschirm auszugeben, und auch nichts zu initialisieren ist, braucht es die Methoden init(), start() und stop()
nicht.
In der paint()-Methode wird die eigentliche Arbeit dieses Applets ausgeführt. Das Graphics-Objekt, das
paint() übergeben wird, enthält den Grafikstatus - d.h. die aktuellen Eigenschaften der Zeichenoberfläche.
Zeile 9 richtet die Schrift für den Grafikstatus ein (im Font-Objekt in der Instanzvariablen f, die in Zeile 6
erzeugt wird). Zeile 10 richtet die Farbe ein (aus einem Objekt, das die Farbe rot darstellt, und das in der
Color-Klassenvariablen red abgelegt ist).
Zeile 11 gibt den String Hello Again! aus, wozu es die aktuelle Schrift und Farbe verwendet und die
Ausgabe an den Koordinaten 5,50 vornimmt. Beachten Sie, daß die Koordinaten 0,0 in der oberen linken
Ecke der Zeichenoberfläche des Applets liegen, wobei ein positives x nach rechts geht, ein positives y nach
unten. Abbildung 8.1 zeigt, wie das Feld und der String des Applets auf die Seite gezeichnet werden.
Abbildung 8.1: Das Applet für HelloAgainApplet2
Nachdem Sie eine Klasse oder Klassen erzeugt haben, die Ihr Applet enthalten, und sie in Klassendateien
kompiliert haben, so wie Sie es für jedes andere Java-Programm auch machen würden, müssen Sie eine
Web-Seite erzeugen, die das Applet aufnimmt. Dazu verwenden Sie HTML (HyperText Markup
Language). Es gibt ein spezielles HTML-Tag-Paar, mit dem Applets in Web-Seiten eingebettet werden.
Java-fähige Browser verwenden die Information aus diesem Tag-Paar, um die kompilierten Klassendateien
zu finden und das Applet auszuführen. In diesem Abschnitt erfahren Sie, wie Java Applets auf einer
Web-Seite ablegt und wie diese Dateien zum Web im Ganzen beitragen.
Um ein Applet auf eine Web-Seite einzubetten, verwenden Sie die Tags <APPLET> und <\APPLET>.
Dieses Tag-Paar stellt eine spezieller Erweiterung von HTML zum Einbetten von Applets in Web-Seiten
dar.
Listing 8.2 zeigt ein einfaches Beispiel für eine HTML-Seite mit eingebettetem Applet, ähnlich dem aus
Kapitel 3, allerdings mit etwas mehr HTML-Code.
1: <HTML> Und hier einige der anderen Ergänzungen dieser HTML-Seite:
Mit einer kompilierten Klassendatei und einer HTML-Datei, die Ihr Applet aufnimmt, sollten Sie jetzt in der
Lage sein, diese HTML-Datei in Ihren Java-fähigen Browser zu laden (entweder mit Datei öffnen oder über
eine URL-Datei ). Der Browser lädt und parst Ihre HTML-Datei und lädt dann Ihre Applet-Klasse und
führt sie aus.
Abbildung 8.2 zeigt das ausgeführt Applet im appletviewer.
Abbildung 8.2: HelloAgainApplet2 im appletviewer
Nachdem Sie ein Applet und eine HTML-Datei haben und sichergestellt haben, daß auf Ihrem lokalen
System alles korrekt läuft, stellen Sie das Applet jetzt im World Wide Web zur Verfügung, so daß jeder mit
einem Java-fähigen Browser es ansehen kann.
Java-Applets werden vom Server so unterstützt wie HTML-Dateien, Bilder und andere Medien. Sie
brauchen keine spezielle Server-Software, um im Web Java-Applets zur Verfügung zu stellen. Sie müssen
Ihren Server nicht einmal konfigurieren. Wenn Sie einen Web-Server haben oder Ihnen Platz auf einem
Web-Server zur Verfügung steht (etwa von Ihrem ISP), müssen Sie nur Ihre .html- und die kompilierte
.class-Datei auf diesen Server kopieren, so wie alle anderen Dateien auch.
Wenn sie noch keinen Web-Server haben, können Sie einen solchen einrichten. Wie das geht, kann im
Rahmen dieses Buchs jedoch nicht besprochen werden. Die meisten von uns mieten jedoch Platz auf dem
Server eines anderen. Die meisten ISPs, also diejenigen, die uns unsere Internet-Email-Accounts zur
Verfügung stellen, würden sich glücklich schätzen, Ihnen mit gebührenpflichtigem Plattenspeicher auf ihrem
Server dienen zu können. Wenn Sie eine Home-Page auf Ihrem ISP-Account haben, steht Ihnen
möglichweise bereist Platz zur Verfügung und Sie brauchen nicht mehr. Wenn Sie noch keinen eigenen
Web-Server haben und das auch nicht in Erwägung ziehen, sollten Sie sich mit Ihrem ISP in Verbindung
setzen.
In seiner einfachsten Form erzeugt <APPLET> unter Verwendung von CODE, WIDTH und HEIGHT
einen Platz geeigneter Größe und führt das Applet dort aus. <APPLET> bieet jedoch noch mehrere
Attribute, die helfen sollen, Ihr Applet in das Gesamtdesign Ihrer Web-Seite einzufügen. Unter anderem
handelt es sich dabei um ALIGN, HSPACE, VSPACE, and CODEBASE.
Das Attribut ALIGN definiert, wie das Applet auf der Seite ausgerichtet wird. Es kann einen von neun
Werten annehmen: LEFT, RIGHT, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM und
ABSBOTTOM.
Für ALIGN=LEFT wird das Applet am linken Rand der Seite angelegt und der gesamte folgende Text fließt
in den Platz rechts von diesem Applet. ALIGN=RIGHT bewirkt genau das Gegenteil. Der Text fließt in
diesen Bereich, bis das Ende des Applets erreicht ist, oder bis Sie <BR> mit CLEAR auf die Startzeile des
Texts unter dem Applet setzen. Das Attribut CLEAR kann einen von drei Werten annehmen.
CLEAR=LEFT beginnt die Textausgabe am nächsten freien linken Rand, CLEAR=RIGHT beginnt die
Textausgabe am nächsten freien rechten Rand, und CLEAR=ALL startet den Text in der Zeile, in der beide
Ränder frei sind.
Hier folgt der Rumpf einer HTML-Datei, die ein Applet am linken Rand ausrichtet, Text daneben
vorbeifließen läßt und dann an das Ende des Absatzes springt, so daß der nächste Text unterhalb des
Zeichenbereichs für das Applet beginnt.
<BODY> Abbildung 8.3 zeigt, wie dieses Applet und der Text um das Applet in einem Java-fähigen Browser
aussehen könnte.
Abbildung 8.3: Ein links ausgerichtetes Applet
Für kleinere Applets können Sie Ihr Applet in eine einzelne Codezeile einbinden. Dazu legen die sieben
anderen Werte für ALIGN fest, wie das Applet vertikal mit dem Text ausgerichtet wird.
Abbildung 8.4 zeigt die verschiedenen Ausrichtungen, wobei die Zeile ein Bil dist und der Pfeil ein kleines
Applet namens ArrowApplet.
Abbildung 8.4: Optionen für die Ausrichtung eines Applets im Text
Die Attribute HSPACE und VSPACE werden verwendet, um den Platz zwischen einem Applet und dem
umschließende Text anzugeben, dargestellt in Pixel. HSPACE gibt den horizontalen Platz an (den Platz links
und rechts vom Applet), VSPACE den vertikalen Platz (den Platz unterhalb und oberhalb des Applets).
Beispielsweise folgt hier das <APPLET>-Tag für das HTML-Beispiel, das Sie bereits gesehen haben, mit
einem vertikalen Platz von 30 und einem horizontalen Platz von 30:
<P><APPLET CODE="HelloAgainApplet2.class" WIDTH=200 HEIGHT=100 Das Ergebnis könnte in einem Java-fähigen Browser aussehen wie in Abbildung 8.5 gezeigt (siehe
Abbildung 8.5).
Abbildung 8.5: Vertikaler und horizontaler Platz
Wenn Sie dies mit Abbildung 8.3 vergleichen, sehen Sie schon, daß der Zeichenbereich des Applets jetzt
Pufferzonen zwischen sich und dem umschließende Text hat.
CODE gibt den Namen der Klassendatei an, die den kompilierten Java-Code für das aktuelle Applet
enthält. Wenn CODE im <APPLET>-Tag allein angegeben ist, wird die .class-Datei im selben Verzeichnis
wie die .html-Datei gesucht.
Wenn Sie Ihre Klassendatei in einem anderen Verzeichnis als Ihre HTML-Dateien ablegen wollen, müssen
Sie dem Browser mitteilen, wo er diese Klassendateien findet. Dazu müssen Sie das CODEBASE-Attribut
verwenden. CODE enthält nur den Namen der Klassendatei, CODEBASE gibt den Pfadnamen an, unter
dem eine Klasse gefunden werden kann. Angenommen, Sie haben ein Verzeichnis, in dem Sie Ihre
HTML-Dateien aufbewahren, und in demselben Verzeichnis haben Sie das Unterverzeichnis myapplets, wo
Sie die entsprechenden Klassendateien ablegen. Das <APPLET>-Tag könnte für die Klassendatei
myclass.class wie folgt aussehen:
<APPLET CODE="myclass.class" CODEBASE="myapplets" In Java-Anwendungen können Sie Ihrer main()-Routine Parameter übergeben, indem Sie Argumente in der
Befehlszeile spezifizieren. Anschließend übernehmen Sie die Argumente in den Rumpf Ihrer Klasse und die
Anwendung verhält sich dementsprechend.
Applets haben keine Befehlszeile, weil sie eigentlich Unterroutinen sind, die im Browser ausgeführt werden.
Wie können Sie einem Applet aber dann unterschiedliche Argumente übergeben? Applets können die
Eingaben aus der HTML-Datei erhalten. Dazu brauchen Sie zweierlei Dinge:
Applet-Parameter haben zwei Attribute: NAME und VALUE. Der NAME gibt einfach nur einen Namen
an, den Sie wie jeden anderen Bezeichner in Ihrem Code wählen. VALUE gibt den Wert des betreffenden
Parameters an. Sie können beispielsweise für eine HTML-Seite die Farbe des Texts im Applet variieren,
indem Sie einen Parameter mit dem Namen color und dem Wert red angeben, während Sie für eine andere
HTML-Seite den Wert blue spezifizieren.
In der HTML-Datei, die das eingebettete Applet enthält kennzeichnen Sie die Parameter mit dem Tag
<PARAM>, das die NAME- und VALUE-Attribute verwendet. <PARAM> steht zwischen <APPLET>
und </APPLET>.
<APPLET CODE="MyApplet.class" WIDTH=100 HEIGHT=100> Dieses Beispiel definiert für das Applet MyApplet zwei Parameter: einen mit dem Namen font und dem
Wert TimesRoman, und einen zweiten mit dem Namen size und dem Wert 36.
Parameter werden dem Applet beim Laden übergeben. In der init()-Methode für Ihr Applet können Sie
diese Parameter mit getParameter() ermitteln. Diese Methode nimmt ein Argument entgegen, nämlich einen
String, der den Namen des gesuchten Parameters enthält, und gibt einen String mit dem entsprechenden
Wert dieses Parameters zurück. (Wie Argumente in Java-Anwendungen werden alle Parameterwerte als
Strings zurückgegeben.) Um den Wert des font-Parameters aus der HTML-Datei zu ermitteln, würden Sie
etwa folgendes in Ihrer init()-Methode angeben:
String theFontName = getParameter("font");
Wenn ein Parameter, den Sie erwarten, nicht in der HTML-Datei angegeben wurde, ergibt getParameter()
null. Häufig ist es sinnvoll, auf einen null-Parameter zu prüfen und einen sinnvollden Standardwert
bereitzustellen:
if (theFontName == null) Beachten Sie, daß getParameter() Strings zurückgibt. Wenn Sie wollen, daß ein Parameter einen anderen
Typ hat, müssen Sie ihn selbst umwandeln. Um den size-Parameter aus der HTML-Datei zu holen und ihn
der Integer-Variablen theSize zuzuweisen, würden Sie etwa folgendes schreiben:
int theSize; Verstanden? Noch nicht? Gut, wir machen ein Beispiel mit einem Applet, das diese Techniken anwendet.
Wir ändern den Code von HelloAgainApplet2 so, daß er Hallo zu einer bestimmten Person sagt, etwa Fran
oder Chris. Der Name wird dem Applet über einen HTML-Parameter übergeben. Wir beginnen mit dem
Kopieren der Klasse HelloAgainApplet2 und legen sie unter dem Namen HelloAnybodyApplet ab:
import java.awt.*; Zuerst brauchen Sie in dieser Klasse einen Platz für den Namen. Weil Sie diesen Namen im gesamten
Applet brauchen, fügen Sie eine Instanzvariable dafür ein
Um einen Wert für helloName zu setzen, müssen Sie den Parameter ermitteln. Am bsten werden Parameter
für ein Applet in einer init()-Methode verarbeitet. Die init()-Methode ist ähnlich der paint()-Methode
definiert (public mit dem Rückgabetyp void aber ohne Argumente). Achten Sie darauf, immer auf den
null-Wert zu testen. Der Standard ist in diesem Fall, Hallo zu Chris zu sagen, wenn kein Name angegeben
wird:
public void init() { Als letzes müssen Sie den Namen so verarbeiten, daß sich ein vollständiger String ergibt, also Hello und
Leerzeichen an den Anfang und ein Ausrufezeichen an den Schluß. Das könnten Sie in der paint()-Methode
ausführen, unmittelbar, bevor der String auf den Bildschirm ausgegeben wird. Weil paint() jedoch bei jedem
Neuzeichnen des Bildschirms ausgeführt wird, ist es effizienter, diese Zeile statt dessen in die init()-Methode
zu schreiben:
helloName = "Hello " + helloName + "!";
Und jetzt müssen Sie nur noch die paint()-Methode modifzieren. Sie wollen den Literal-String Hello Again!
durch die drawString()-Methode mit dem variablen name ersetzen:
g.drawString(helloName, 5, 50);
Listing 8.3 zeigt die endgültige Version der Klasse HelloAnybodyApplet.
Listing 8.3: HelloAnybodyApplet.java
1: import java.applet.*; Jetzt legen Sie eine Kopie der Datei HelloAgain2.html an und geben ihr den Namen
HelloAnybodyApplet1.html und bearbeiten sie so, daß sie ihr Parameter übergeben können. Listing 8.4
zeigt den neuen HTML-Code für das Applet HelloAnybodyApplet.
Listing 8.4: HelloAnybodyApplet1.html
1: <HTML> In Zeile 7 haben wir das <APPLET>-Tag, das auf die Klassendatei für das Applet zeigt. In Zeile 8 steht das
<PARAM>-Tag, mit dessen Hilfe Sie den Namen übergeben. Hier ist der Parameter NAME einfach name,
und VALUE ist Fran.
Um dies vom JBuilder aus auszuführen, fügen Sie einfach die Dateien HelloAnybodyApplet.java und
HelloAnybodyApplet1.html in das Projekt AppletsAppsWizards.jpr ein. Kompilieren Sie
HelloAnybodyApplet.java, klicken Sie mit der rechten Maustaste auf den HTML-Knoten im
Navigations-Bereich und wählen Sie Start. Der appletviewer zeigt das in Abbildung 8.6 dargestellte
Ergebnis an
Abbildung 8.6: HelloAnybodyApplet1.html im appletviewer
Jetzt führen wir ein zweites Beispiel aus. Sie wissen, daß in HelloAnybodyApplet.java als Standardname
Chris angegeben wird. Listing 8.5 zeigt eine HTML-Seite, die der Datei H HelloAnybodyApplet1.html sehr
ähnlich ist; HelloAnybodyApplet2.html hat jedoch keine Parameter für name.
Listing 8.5: HelloAnybodyApplet2.html
1: <HTML> Weil hier kein Name angegeben wird, verwendet das Applet den Standard. Um dies im JBuilder
auszuführen, müssen Sie dem Projekt die Datei HelloAnybodyApplet2.html hinzufügen. Wenn Sie diese
HTML-Datei ausführen, zeigt der appletviewer das Ergebnis in Abbildung 8.7 an:
Abbildung 8.7: HelloAnybodyApplet2.html im appletviewer
Applet-Parameter bieten dieselbe Flexibilität wie Befehlszeilenparameter in Anwendungen. Sie erlauben, das
Applet »wiederzuverwenden«, indem auf verschiedenen HTML-Seiten Parameter angegeben werden, die
es entsprechend verarbeitet.
Für Anwendungen ist anders als für Applets kein Java-fähiger Browser erforderlich, um sie in einer
HTML-Web-Seite anzusehen. Anwendungen sind Java-Programme, die unabhängig ausgeführt werden
können. Für sie muß keine Java-VM auf der Client-Maschine installiert sein, so daß Anwendungen Zugriff
auf den Laufzeit-Interpreter haben.
Eine Java-Anwendung besteht aus einer oder mehreren Klassen und kann beliebig groß oder klein sein.
HotJava ist ein gutes Beispiel für eine große Java-Anwendung. Alles, was Sie brauchen, damit eine
Java-Anwendung läuft, ist eine Klasse, die als »Absprungpunkt« für das restliche Java-Programm dient.
Wenn Ihr Programm klein genug ist, braucht es vielleicht nur aus dieser einen Klasse zu bestehen.
Die Sprungbrett-Klasse für Ihr Programm braucht eine main()-Methode. Wenn Sie Ihre kompilierte
Java-Klasse ausführen (unter Verwendung des VM-Interpreters), wird zuerst die main()-Methode
aufgerufen. Das sollte Sie nicht überraschen - Sie haben ja die ganze Zeit Anwendungen mit
main()-Methoden erstellt.
Die Signatur für die main()-Methode sieht immer wie folgt aus:
public static void main(String args[]) {...}
Hier die Teile, aus denen sie sich zusammensetzt:
Der Rumpf der main()-Methode enthält Code, den Sie zum Starten Ihrer Anwendung brauchen: für die
Initialisierung von Variablen oder zum Anlegen von Klasseninstanzen.
Wenn Java main() ausführt, sollten Sie beachten, daß es sich dabei um eine Klassenmethode handelt. Die
Klasse, die sie enthält, wird bei der Programmausführung nicht automatisch instantiiert. Wenn Sie diese
Klasse als Objekt behandelt wollen, müssen Sie main() selbst instantiieren. (Alle Beispiele haben das bisher
gemacht.)
Weil Java-Anwendungen Standalone-Programme sind, ist es sinnvoll, eine Möglichkeit zu schaffen, ihnen
Argumente oder Optionen zu übergeben, die die Ausführung steuern, oder einem generischen Programm
ermöglichen, verschiedene Eingaben zu verarbeiten. Befehlszeilenargumente können für verschiedene
Zwekke genutzt werden. Sie können sie beispielsweise zum Debugging von Eingaben verwenden, um
Dateinamen anzugeben, aus denen gelesen oder in die geschrieben werden soll, oder für jede andere
Information, die Sie Ihrem Java-Programm übergeben wollen.
Um einem Java-Programm Argumente zu übergeben, fügen Sie diese einfach beim Programmstart an die
Befehlszeile an:
java myprogram argumentOne 2 three
In dieser Befehlszeile haben Sie drei Argumente: argumentOne, 2 und three. Beachten Sie, daß die
Argumente durch Leerzeichen getrennt werden, die folgende Befehlszeile würde also auch drei Argumente
übergeben:
Um Argumente zu gruppieren, schließen Sie sie in doppelte Anführungszeichen ein. Das folgende erzeugt ein
Argument:
Die doppelten Anführungszeichen werden entfernt, bevor das Argument der main()-Methode in Ihrem
Programm übergeben wird, aber sie sind notwendig, um den Text als ein einzelnes Argument zu
kennzeichnen.
Wie verarbeitet Java Argumente? Es speichert sie als String-Arrays, die der main()-Methode in Ihrem
Java-Programm übergeben werden. Hier noch einmal die Signatur für main():
public static void main (String args[]) {...}
Hier ist args der Name des String-Arrays mit der Argumenteliste. Sie können alles aufrufen, was Sie wollen.
In Ihrer main()-Methode können Sie die Argumente verarbeiten, die Ihrem Programm übergeben werden,
indem Sie das Array durchlaufen und die gewünschte Verarbeitung vornehmen.
Betrachten Sie beispielsweise die Klasse EchoArgs in Listing 8.6.
1: class EchoArgs { Um einer Java-Anwendung aus der IDE Argumente zu übergeben, wählen Sie Start | .... Geben Sie nicht
java oder den Programmnamen ein, sondern nur die Argumente für Ihr Programm. Abbildung 8.8 zeigt das
Feld Befehlszeilenparameter, wo Argumente eingegeben werden können.
Abbildung 8.8: Der Parameter-Dialog für die Eingabe von Argumenten
Klicken Sie im Feld Vorgegebene ausführbare Datei auf den Dropdown-Pfeil und wählen Sie das
Programm EchoArgs.java aus. Stellen Sie sicher, daß das Optionsfeld Ausgabe zum
Ausführungsprotokoll senden selektiert ist, und klicken Sie auf OK. Wählen Sie Ansicht
Ausführungsprotokoll, damit Sie die Ausgabe bei der Programmausführung beobachten können, und klicken
Sie in der Symbolleiste auf Start. Mit diesen Befehlszeilenargumenten ergibt das Programm die folgende
Ausgabe im Ausführungsprotokoll-Fenster:
Jetzt geben Sie die folgenden Argumente in den Parameter-Dialog ein:
Mit diesen Argumenten erzeugt das Programm die folgende Ausgabe im Ausführungsprotokoll-Fenster:
Listing 8.7: SumAverageNot.java
1: class SumAverageNot { Fehler: (6) incompatible types; found: java.lang.String, required: int.
Dieser Fehler tritt auf, weil Sie in Zeile 6 versuchen, sum ein Element des args-Arrays zuzuweisen. Um
dieses Problem zu lösen, müssen Sie die Argumente in Integer umwandeln, bevor Sie sum die Werte
zuweisen können. Glücklicherweise gibt es eine praktische Methode in der Integer-Klasse, nämlich
parseInt(), die genau das tut. Ändern Sie Zeile 6 in SumAverage, so daß sie jetzt wie in Listing 8.8 aussieht.
1: class SumAverage { Jetzt sollte es funktionieren. Wählen Sie Start | Parameter, um den Parameter-Dialog aufzurufen, wählen
Sie SumAverage.java als die vorgegebene ausführbare Datei und geben Sie die folgenden
Befehlszeilenargumente ein:
Im Ausführungsprotokoll erscheint die folgende Ausgabe:
Was passiert, wenn Sie ein Programm als Applet und als Anwendung verwenden wollen? Java ermöglicht
Ihnen das, indem einfach in den Code die Funktionalität für beide Formen eingegeben wird (auch die
Methode main()). Wenn die Klasse vom <APPLET>-Tag in einer HTML-Seite aufgerufen wird, wird sie
als Applet ausgeführt (vorausgesetzt, der Code steht zur Verfügung), wenn die Klasse vom Betriebssystem
aufgerufen wird, wird sie als Anwendung ausgeführt (vorausgesetzt, die main()-Methode ist vorhanden). Mit
anderen Worten, der VM-Interpreter ist intelligent genug, um den Kontext zu erkennen, in dem die
Klassendatei aufgerufen wird, und führt dann den richtigen Abschnitt der Klasse aus.
Listing 8.9 zeigt, wie HelloAnybodyApplet so umgeschrieben wird, daß es auch als
Standalone-Java-Anwendung eingesetzt werden kann, HelloAnybody.
Listing 8.9: HelloAnybody.java
1: import java.applet.*; Listing 8.10: HelloAnybody.html
1: <HTML> Jetzt sind Sie fertig. Wählen Sie Datei | Alles speichern und führen Sie Ihr Programm als Applet aus,
indem Sie mit der rechten Maustaste auf den Knoten HelloAnybody.html klicken und Start auswählen. Die
Ergebnisse werden im appletviewer-Fenster angezeigt.
Führen Sie das Programm jetzt standalone aus, indem Sie Start | Parameter auswählen und im Feld für die
vorgegebene ausführbare Datei HelloAnybody.java eingeben. Geben Sie als Befehlszeilenargument Kristi
ein und klicken Sie auf OK. Wählen Sie in der Symbolleist Start. Das Ausführungsprotokoll-Fenster erzeugt
die folgende Ausgabe.
Am besten definieren Sie ein solches Programm, das in zwei Formen ausgeführt werden soll, zunächst als
Applet, und stellen sicher, daß alle Ausgabevariablen als Instanzvariablen definiert sind. Anschließend
erzeugen Sie eine HTML-Datei und testen das Applet. Wenn es korrekt läuft, fügen Sie die
main()-Methode ein, so daß Ihre Klassendatei auch als Standalone-Anwendung ausgeführt werden kann.
Ein JBuilder-Projekt besteht aus Dateien, die Sie als Gruppe behandeln wollen, wie etwa für eine
Anwendung oder ein Applet. In JBuilder wird die Projektdatei, die alle Teile eines Projekts verwaltet, mit
der Dateinamenerweiterung .jpr angelegt. Wenn Sie im Browser eine existierende .jpr-Datei öffnen, werden
alle enthaltenen Elemente im Navigations-Bereich angezeigt.
Eine Projektdatei wird durch Datei | Neues Projekt angelegt, wodurch der in Abbildung 8.9 gezeigte
Dialog angezeigt wird.
Abbildung 8.9: Der Projekt-Experte
In diesem Dialog geben Sie in das Feld Datei Informationen über den Projektnamen und das Paket an. Sie
wissen, daß Pakete in einer Verzeichnishierarchie angeordnet sind, so daß Sie den vollständigen Pfadnamen
und Dateinamen für Ihr Projekt eingeben müssen, um JBuilder mitzuteilen, wohin das Projekt gehört. Sie
können den Pfad und den Dateinamen entweder manuell eingeben, wie Sie es in der Vergangenheit getan
haben, oder Sie klicken auf die Schaltfläche Durchsuchen, um ein bestimmtes Verzeichnis für das neue
Projekt auszuwählen.
Sie können optional einen Titel, einen Autor, eine Firma und eine Beschreibung eingeben. Diese Information
wird in eine HTML-Datei mit demselben Wurzelnamen wie Ihr Projekt eingefügt. Wenn Sie auf die
Schaltfläche Fertigstellen klikken, öffnet der JBuilder die .jpr-Datei im Speicher und bereitet sie auf die
Aufnahme von Dateien vor, die Sie Ihrem Projekt hinzufügen wollen.
Die Aufteilung Ihrer Projekte in Pakete ist sinnvoll. Dadurch können Sie Ihre Pakete in Abschnitte
unterteilen, die unabhängig kompiliert und debugged werden können. In diesem Kapitel haben Sie alle
Dateien dem Projekt AppletAppsWizards hinzugefügt. Anschließend können Sie alle heute erstellten Listings
mit einem einzigen Befehl kompilieren. s
Neben den .java- und .html-Dateien, die Sie Ihren Projekten bisher hinzugefügt haben, gibt es noch
zahlreiche andere Dateien, die in ein Projekt aufgenommen werden können. Tabelle 8.1 zeigt, um welche
Dateitypen es sich dabei handeln kann und gibt jeweils eine kurze Erklärung dazu.
Tabelle 8.1: JBuilder-Projektdateien
Backup-Dateien für .java- und .html-Dateien; ermöglichen, Dateiinhalt nach dem Speichern auf
die Platte wiederherzustellen. Nachdem Sie Erfahrung mit Applets und Anwendungen gesammelt haben, können Sie diese durch die IDE
erzeugen lassen, was viel einfacher ist. Dieser Abschnitt zeigt Ihnen die Experten, die Code-Gerüste für Ihre
Java-Programme erzeugen.
Sie haben bereits einen Experten kennengelernt, den Projekt-Experten, mit dem Sie neue Projekte erzeugt
haben. Sie haben das doch getan? JBuilder stellt noch zwei weitere Experten zur Verfügung, den
Applet-Experten und den Anwendungs-Experten. Diese Experten präsentieren verschiedene Dialoge, in
denen Sie die Optionen spezifizieren, die das gewünschte Projekt haben soll.
Zuerst stellen Sie sicher, daß das aktuelle Projekt geöffnet ist, weil Sie ihm dieses Applet hinzufügen. Jetzt
erzeugen Sie mit Hilfe des Experten ein Java-Applet, indem Sie Datei | Neu auswählen, um den
Neu-Dialog anzuzeigen. Klicken Sie auf der Datei-Seite auf das Applet-Icon und dann auf OK. Der
Applet-Experte erscheint und führt Sie durch mehrere Dialoge.
Der erste Dialog fragt Sie nach dem Namen des Pakets und der Klasse für das Paket. Markieren Sie das
Feld Package, drücken Sie die Entfernen-Taste, um es zu löschen, und geben Sie GreenApplet in das
Klasse-Feld ein. Beachten Sie, daß im Datei-Feld Ihre Eingabe automatisch reflektiert wird.
Abbildung 8.10: Applet-Experte: Schritt 1 von 3
Dieser Dialog ermöglicht Ihnen, festzulegen, ob Kommentare und Methoden erzeugt werden sollen, und ob
das Applet auch als Anwendung verwendet werden soll. Füllen Sie den Dialog wie in Abbildung 8.10
gezeigt aus. Klicken Sie auf die Schaltfläche Weiter.
Im nächsten Dialog werden Sie nach den Namen und anderen Details über die Parameter für das Applet
gefragt, wie in Abbildung 8.11 gezeigt.
Abbildung 8.11: Applet-Experte: Schritt 2 von 3
Dieses Applet nimmt keine Parameter entgegen, deshalb klicken Sie einfach auf Weiter.
Der nächste Dialog fragt, ob Sie der Experte eine HTML-Seite erzeugen soll. Sie brauchen eine, also
markieren Sie das Kontrollkästchen HTML-Seite und geben Sie in das Name-Feld TestGreenApplet ein,
wie in Abbildung 8.12 gezeigt.
Abbildung 8.12: Applet-Experte: Schritt 3 von 3
Wenn Sie fertig sind, klicken Sie auf die Schaltfläche Fertigstellen. Jetzt erzeugt die IDE die
Quellcode-Dateien, .java und .html, die für die Unterstützung Ihrer Einstellungen benötigt werden. Sie sehen,
daß dem aktuellen Projekt zwei Dateien hinzugefügt werden: GreenApplet.html und GreenApplet.java.
Wenn die IDE den Code fertig hat, klicken Sie im Navigationsbereich auf den Eintrag GreenApplet.html und
dann im Inhalts-Bereich auf die Registerkarte Quelltext.
Sie wollen jetzt vielleicht Anpassungen an der HTML-Datei vornehmen, damit diese Ihren Bedürfnissen
entspricht. Jetzt wollen wir den Titel und die Breite ändern. Klicken Sie auf den Inhaltsbereich in der Zeile
unterhalb des <TITLE>-Tags, die den Inhalt HTML-Testseite hat, und drücken Sie Shift+Ende, um die
ganze Linie zu selektieren. Geben Sie jetzt als neuen Titel GreenApplet lebt! ein, der dann als neuer Title im
Fenster der HTML-Seite angezeigt wird. Drücken Sie den Pfeil nach unten, bis der Cursor auf dem Attribut
WIDTH steht, drücken Sie Ende und dann Shift+Strg+Linker Pfeil, um den Wert 400 zu selektieren. Geben
Sie 600 als neue Breite ein. Das Applet erscheint jetzt in einem rechteckigen Bereich, der 600x300 Pixel
groß ist. Abbildung 8.13 zeigt die resultierende HTML-Datei.
Abbildung 8.13: GreenApplet.html
Wählen Sie Datei | Speichern, um Ihre Änderungen festzuhalten. Jetzt passen Sie die Applet-Datei an.
Die HTML-Seite und der Applet-Code wurden zwar für Sie erzeugt, aber Sie wollen eine Codezeile in der
jbInit()-Methode ändern und eine paint()-Methode einfügen.
Dazu klicken Sie im Navigator-Bereich auf den Eintrag GreenApplet.java. Im Struktur-Bereich blättern Sie
nach unten bis zur Methode jbInit() und klicken dann auf diesen Eintrag. Der Cursor im Inhalts-Bereich wird
automatisch auf dieser Methode positioniert, wie in Abbildung 8.14 gezeigt.
Abbildung 8.14: Der AppBrowser mit der Methode jbInit()
Klicken Sie auf die markierte Linie und verschieben Sie den Cursor nach unten auf den Text 400 und geben
Sie statt dessen 600 ein, wie folgt:
Klicken Sie im Struktur-Feld auf die start()-Methode und im Inhalts-Bereich zwischen die start()- und die
stop()-Methode und fügen Sie die paint()-Methode ein, wie in Abbildung 8.15 gezeigt.
Abbildung 8.15: Die neue paint()-Methode
Wählen Sie Datei | Speichern. Führen Sie das Applet aus und beobachten Sie, was passiert. Betrachten
Sie die .java-Datei genauer und schauen Sie, welche Variablen und Methoden JBuilder automatisch für Ihre
Applets bereitgestellt hat. Mehr darüber erfahren Sie in den nächsten Lektionen.
Stellen Sie sicher, daß das aktuelle Projekt geöffnet ist. Erzeugen Sie eine Java-Anwendung mit dem
Experten. Dazu wählen Sie Datei | Neu, um den Neu-Dialog anzuzeigen. Klicken Sie auf das
Anwendungs-Icon und dann auf OK. Der Anwendungs-Experte zeigt mehrere Dialoge an, durch die Sie
geführt werden.
Im ersten Dialog geben Sie den Namen der Anwendungsklasse in, Hello, und Sie entscheiden, ob
Kommentare erzeugt werden, wie in Abbildung 8.16 gezeigt.
Abbildung 8.16: Anwendungs-Experte. Schritt 1 von 2
Klicken Sie auf die Schaltfläche Fertigstellen, wenn Ihre Anwendung keine
Benutzeroberflächen-Komponenten verwenden will (mit anderen Worten, es wird eine
Befehlzeilen-Anwendung). Größtenteils werden Sie jedoch Benutzeroberflächen-Komponente brauchen,
dann klicken Sie auf Weiter.
Im nächsten Dialog werden Sie nach dem Namen der Frame-Klasse gefragt. Sie wissen, ein Frame ist ein
Fenster, das Benutzeroberflächen-Komponenten aufnimmt. Dieser Dialog erlaubt außerdem, anzugeben,
welche generischen Methoden und Komponenten automatisch für Sie angelegt werden. Füllen Sie das
Name-Feld wie in Abbildung 8.17 gezeigt aus.
Abbildung 8.17: Anwendungs-Experte: Schritt 2 von 2
Wenn Sie fertig sind, klicken Sie auf die Schaltfläche Fertigstellen. Die IDE erzeugt die Quellcodedateien
für Ihre Einstellungen.
Applets bilden die gebräuchlichste Anwendung der Sprache Java. Applets sind komplizierter als viele
Java-Anwendungen, weil sie in Web-Seiten ausgeführt werdenaber sie können auf die Grafik, die
Benutzeroberfläche und die Ereignisstruktur des Web-Browsers zugreifen. Heute haben Sie die Grundlagen
kennengelernt, wie Sie Applets erzeugen.
Außerdem haben Sie erfahren, wie man Anwendungen erzeugt, und wie Programme für beide Zwecke
angelegt werden, die sowohl als Applets als auch als Anwendungen eingesetzt werden können. Schließlich
haben Sie ein Projekt erzeugt, das sowlhl als Applet als auch als Anwendung eingesetzt werden kann, wozu
die Experten der JBuilder-IDE verwendet wurden.
F Im ersten Teil der heutigen Lektion haben Sie gesagt, daß Applets von beliebigen Web-Servern
heruntergeladen und auf dem System des Clients ausgeführt werden. Wie können Sie einen
Applet-Entwickler daran hindern, ein Applet zu erzeuge, das alle Dateien auf dem System des Clients
löscht oder die Sicherheit auf andere Weise gefährdet?
A Java-Applets weisen bestimmte Einschränkungen auf, die es schwierig machen, ein feindseliges Verhalten
auszuführen. Weil Java-Applets die Dateien auf dem Client-System nicht lesen und nicht schreiben kann,
können sie auch keine privaten Informationen löschen. Weil sie keine Programme auf dem System des Clients
ausführen dürfen, ohne daß Sie dies explizit erlauben, können sie auch keine Systemprogramme ausführen, die
beispielsweise behaupten, sie wären Sie. Und sie können auch nicht so viele Programme ausführen, daß Ihr
System abstürzt.
Der Workshop bietet zwei Möglichkeiten, zu überprüfen, was Sie in diesem Kapitel gelernt haben. Der
Quiz-Teil stellt Ihnen Fragen, die Ihnen helfen sollen, Ihr Verständnis für den vorgestellten Stoff zu vertiefen.
Die Antworten auf die Fragen finden Sie in Anhang A. Der Übungen-Teil ermöglicht Ihnen, Erfahrungen in
der Anwendung der Dinge zu sammeln, die Sie hier kennengelernt haben. Versuchen Sie, diese Dinge
durchzuarbeiten, bevor Sie mit der nächsten Lektion weitermachen.
Verwenden Sie Listing 8.11 als Grundlage und nehmen Sie die folgenden Änderungen am HTML-Code
vor. Geben Sie der resultierenden Datei den Namen HeyYouApplet2.html:
Listing 8.11: HeyYouApplet.html
1: <HTML> Verwenden Sie Listing 8.12 als Basis und nehmen Sie im Java-Code die folgenden Änderungen vor. Legen
Sie die Datei unter dem Namen HeyYouApplet2.java ab.
Listing 8.12: HeyYouApplet.java
1: import java.awt.Graphics; Die wichtigsten Aktivitäten von Applets
Initialisierung
Starten
Unterbrechen
Zerstören
Technischer Hinweis
Wie unterscheidet sich destroy() von finalize(), das in Lektion 3 vorgestellt wurde? Die destroy()-Methode
wird nur auf Applets angewendet, während finalize() eine allgemeinere Methode darstellt, daß ein Objekt
eines beliebigen Typs nach seiner Ausführung aufräumen kann.
Zeichnen
Ein einfaches Applet
2: import java.awt.*;
3:
4: public class HelloAgainApplet2 extends Applet {
5:
6: Font f = new Font("TimesRoman", Font.BOLD, 36);
7:
8: public void paint(Graphics g) {
9: g.setFont(f);
10: g.setColor(Color.red);
11: g.drawString("Hello again!", 5, 50);
12: }
13: }
Einbetten eines Applets auf einer Web-Seite
Der folgende Abschnitt setzt voraus, daß Sie wenigstens am Rande verstanden haben, wie
HTML-Seiten geschrieben werden. Wenn Sie Hilfe brauchen, können Sie dazu Web-Publishing in 14 Tagen von SAMS zu Rate ziehen.
Die Tags <APPLET> und </APPLET>
Sie werden feststellen, daß hier die Begriffe »HTML-Seite« und »Web-Seite« häufig synonym
verwendet werden. Sie sollten jedoch wissen, daß nicht alle Web-Seiten HTML-basiert sind. Web-Seiten
können auch CGI-Skripts (Common Gateway Interface) sein, die häufig für die Darstellung
formularbasierter Seiten verwendet werden.
2: <HEAD>
3: <TITLE>Hello to Everyone!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>Mein Java-Applet sagt:
7: <BR>
8: <APPLET CODE="HelloAgainApplet2.class" WIDTH = 250 HEIGHT = 100>
9: Hier würde das Applet Applet2 in einem Java-fähigen
10: Browser ausgeführt
11: </APPLET>
12: </BODY>
13: </HTML>
Wenn Sie im IDE-Editor eine HTML-Datei erzeugen oder ändern, wird die neue Version des
Quellcodes im Speicher gehalten, bis Sie sie speichern. Der appletviewer lädt jedoch die bezogene
HTML-Datei direkt von der Platte. Deshalb müssen Sie die HTML-Datei immer speichern, bevor Sie
versuchen, das Applet auszuführen, um sicherzugehen, daß Sie die neueste Version verwenden.
Zu dem Paar <APPLET> und <\APPLET> auf dieser Seite gibt es einige Dinge zu sagen:
Debugging und Testen des Applets
Applets im Web bereitstellen
Das <APPLET>-Tag
ALIGN
<P>My Java applet now says: <BR>
<P><APPLET CODE="HelloAgainApplet2.class" WIDTH=200 HEIGHT=100>
HelloAgainApplet2</APPLET>
Links neben diesem Absatz liegt ein Applet. Es ist ein enfaches Applet, in dem ein kleiner Satz ausgegeben wird, in roter Schrift,
36 Punkt, Times Fett
<BR CLEAR=ALL>
<P>In the next part of the page, we demonstrate how under certain conditions, what appear to be styrofoam peanuts can be used as a healthy snack.
</BODY>
HSPACE und VSPACE
ALIGN=LEFT VSPACE=30 HSPACE=30>
HelloAgainApplet2</APPLET>
CODE und CODEBASE
WIDTH=100 HEIGHT=100></APPLET>
Parameterübergabe in Applets
<PARAM NAME=font VALUE="TimesRoman">
<PARAM NAME=size VALUE="36">
A Java applet appears here.
</APPLET>
Die Namen von Parametern, wie sie in <PARAM> angegeben sind, und die Namen der
Parameter in getParameter() müssen übereinstimmen, auch hinsichtlich der Groß-/Kleinschreibung. Mit
anderen Worten, auch Applet-Parameter berücksichtigen die Groß-/Kleinschreibung! <PARAM
NAME="name"> bedeutet also etwas anderes als <PARAM NAME="Name">. Wenn Ihre Parameter
dem Applet nicht richtig übergeben werden, muß zuerst geprüft werden, ob die Groß-/Kleinschreibung
richtig beibehalten wurde.
theFontName = "CourierNew";
String s = getParameter("size");
if (s == null) theSize = 12;
else theSize = Integer.parseInt(s);
public class HelloAnybodyApplet extends java.applet.Applet {
Font f = new Font("TimesRoman", Font.BOLD, 36);
public void paint(Graphics g) {
g.setFont(f);
g.setColor(Color.red);
g.drawString("Hello again!", 5, 50);
}
}
helloName = getParameter("name");
if (helloName == null)
helloName = "Chris";
}
2: import java.awt.*;
3:
4: public class HelloAnybodyApplet extends Applet {
5:
6: Font f = new Font("TimesRoman", Font.BOLD, 36);
7: String helloName;
8:
9: public void init() {
10: helloName = getParameter("name");
11: if (helloName == null) helloName = "Chris";
12: helloName = "Hello " + helloName + "!";
13: }
14:
15: public void paint(Graphics g) {
16: g.setFont(f);
17: g.setColor(Color.red);
18: g.drawString(helloName, 5, 50);
19: }
20: }
2: <HEAD>
3: <TITLE>Hello to Everyone!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="HelloAnybodyApplet.class" WIDTH=300 HEIGHT=50>
8: <PARAM NAME=name VALUE="Fran">
9: Hello to whoever you are!
10: </APPLET>
11: </BODY>
12: </HTML>
2: <HEAD>
3: <TITLE>Hello to Everyone!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="HelloAnybodyApplet.class" WIDTH=300 HEIGHT=50>
8: Hello to whoever you are!
9: </APPLET>
10: </BODY>
11: </HTML
Anwendungen erzeugen
Befehlszeilenargumente
Argumente auswerten
Listing 8.6: EchoArgs.java
2: public static void main(String args[]) {
3: for (int i = 0; i < args.length; i++) {
4: System.out.println("Argument " + i + ": " + args[i]);
5: }
6: }
7: }
hspace="10">Argument 0: 9
Argument 1: 1
Argument 2: 8
Argument 3: jump
Argument 4: over
Argument 5: the
Argument 6: moon
In Java ist args[0] das erste Argument, nicht der Programmname, wie in C oder UNIX.
hspace="10">Argument 0: aOne
Argument 1: and aTwo
Argument 2: and
Argument 3: aThree
Beachten Sie, daß die einem Java-Programm übergebenen Argumente in einem String-Array abgelegt
werden. Um sie als Nicht-Strings zu behandeln, müssen Sie sie in den gewünschten Typ umwandeln.
Angenommen, Sie haben das einfache Java-Programm SumAverage. Es kann beliebig viele numerische
Argumente entgegennehmen und berechnet den Durchschnitt. Listing 8.7 zeigt einen ersten Blick auf dieses
Programm.
2: // dieses Listing wird nicht kompiliert
3: public static void main(String args[]) {
4: int sum = 0;
5: for (int i = 0; i < args.length; i++) {
6: sum += args[i];
7: }
8: System.out.println("Sum is: " + sum);
9: System.out.println("Average is: " +
10: (float)sum / args.length);
11: }
12: }
Auf den ersten Blick scheint das Programm ganz einfach. Eine for-Schleife durchläuft das
Argumente-Array und summiert sie. Anschließend werden die Summe und der Mittelwert ausgegeben. Aber
was passiert, wenn Sie versuchen, das zu kompilieren? Versuchen Sie es! Sie erhalten die folgende
Fehlermeldung:
Listing 8.8: SumAverage.java
2: // dieses Listing wird kompiliert
3: public static void main(String args[]) {
4: int sum = 0;
5: for (int i = 0; i < args.length; i++) {
6: sum += Integer.parseInt(args[i]);
7: }
8: System.out.println("Sum is: " + sum);
9: System.out.println("Average is: " +
10: (float)sum / args.length);
11: }
12: }
Programme für beide Zwecke
2: import java.awt.*;
3:
4: public class HelloAnybody extends Applet {
5:
6: Font f = new Font("TimesRoman", Font.BOLD, 36);
7: String helloName;
8:
9: public void init() {
10: helloName = getParameter("name");
11: if (helloName == null) helloName = "Chris";
12: helloName = "Hello " + helloName + "!";
13: }
14:
15: public void paint(Graphics g) {
16: g.setFont(f);
17: g.setColor(Color.red);
18: g.drawString(helloName, 5, 50);
19: }
20:
21: public static void main(String args[]) {
22: System.out.print("Hello");
23: if (args.length == 0) {
24: System.out.print(" Chris");
25: }
26: else {
27: for (int i = 0; i < args.length; i++) {
28: System.out.print(" " + args[i]);
29: }
30: }
31: System.out.println("!");
32: }33:
34: }
Damit dieses Programm beide Zwecke erfüllt, fügen Sie die main()-Methode ein, die grundsätzlich
dasselbe tut wie der Applet-Code.
Listing 8.10 zeigt die HTML-Datei für dieses Programm, damit Sie es als Applet ausführen können.
2: <HEAD>
3: <TITLE>Hello to Everyone!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="HelloAnybody.class" WIDTH=500 HEIGHT=100>
8: <PARAM NAME=name VALUE="JBuilder Fans">
9: Hello to whoever you are!
10: </APPLET>
11: </BODY>
12: </HTML>
JBuilder-Projekte
Ein Projekt erzeugen
Wenn Sie dem Projekt SumAverageNot.java hinzufügen, wird die Kompilierung beim
Compiler-Fehler dieser Datei unterbrochen. Wählen Sie einfach den Knoten SumAverageNot.java im
Navigations-Bereich und klicken Sie auf das Icon Aus dem Projekt entfernen (der Ordner mit dem
Minus), um die Datei aus dem Projekt zu entfernen (sie bleibt aber weiterhin auf der Festplatte erhalten,
wenn Sie sie gespeichert haben). Führen Sie die Kompilierung erneut aus, dann sollte die Kompilierung
erfolgreich sein, wenn Sie alles richtig eingegeben haben.
Projektdatei-Erweiterungen
Die Verwendung von Experten
Applet-Experte
Anlegen der Quelldateien
Abänderung der HTML-Datei
Anpassen der Applet-Datei
Anwendungs-Experte
Quelldateien anlegen
Zusammenfassung
F&A
Workshop
Quiz
Übung
2: <HEAD>
3: <TITLE>Hey You!</TITLE>
4: </HEAD>
5: <BODY>
6: <P>
7: <APPLET CODE="HeyYouApplet.class" WIDTH=300 HEIGHT=150>
8: <PARAM NAME=name VALUE="Michelle">
9: Hey out there!
10: </APPLET>
11: </BODY>
12: </HTML>
2: import java.awt.Font;
3: import java.awt.Color;
4:
5: public class HeyYouApplet extends java.applet.Applet {
6:
7: String heyName;
8:
9: public void init() {
10:
11: heyName = getParameter("name");
12: if (heyName == null)
13: heyName = "You";
14: heyName = "Hey " + heyName + "!";
15: }
16:
17: public void paint(Graphics g) {
18: Font f = new Font("TimesRoman", Font.BOLD, 36);
19: g.setFont(f);
20: g.setColor(Color.green);
21: g.drawString(heyName, 5, 50);
22: }
23: }
Ein Imprint des Markt&Technik Buch- und Software- Verlag GmbH
Elektronische Fassung des Titels: JBuilder in 14 Tagen, ISBN: 3-87791-895-6