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.
Diese Einschränkungen verhindern die bekannten Angriffe gegen das System eines Clients, aber
man kann nie ganz sicher sein, daß nicht ein Hacker die Sicherheitseinschränkungen umgeht, eindringt,
CPU-Ressourcen nutzt und Probleme macht. Um die Sicherheit von Java zu testen, hat Sun die
Internet-Gemeinde aufgefordert, in die Java-Sicherheit einzudringen und ein Applet zu erzeugen, das die
Einschränkungen umgeht.
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:
Technischer Hinweis 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.*;
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: }
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.
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.
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.
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.
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>
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: 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>
<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>
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
ALIGN=LEFT VSPACE=30 HSPACE=30>
HelloAgainApplet2</APPLET>
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"
WIDTH=100 HEIGHT=100></APPLET>
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>
<PARAM NAME=font VALUE="TimesRoman">
<PARAM NAME=size VALUE="36">
A Java applet appears here.
</APPLET>
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");
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.
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)
theFontName = "CourierNew";
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;
String s = getParameter("size");
if (s == null) theSize = 12;
else theSize = Integer.parseInt(s);
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.*;
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);
}
}
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() {
helloName = getParameter("name");
if (helloName == null)
helloName = "Chris";
}
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.*;
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: }
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>
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>
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>
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
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.
Listing 8.6: EchoArgs.java
1: class EchoArgs {
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: }
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:
In Java ist args[0] das erste Argument, nicht der Programmname, wie in C oder UNIX. 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 {
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:
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 {
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: }
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.*;
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: HelloAnybody.html
1: <HTML>
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>
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
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.
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>
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>
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;
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: }
