vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


Tag 15

Java-Applets

Java ist eine relativ junge Programmiersprache, die anfänglich vor allem dadurch Furore machte, dass man mit ihrer Hilfe Programme (die sogenannten Applets1) für Webseiten erstellen konnte, die clientseitig ausgeführt werden. Mitte der Neunziger war dies eine Sensation. Nicht nur weil die Programme clientseitig ausgeführt wurden (diesen Vorteil konnte auch das ungefähr zeitgleich erscheinende JavaScript verbuchen), sondern weil hinter den Applets eine mächtige Programmiersprache stand, die den Webdesignern Möglichkeiten eröffnete, an die bei Verwendung von JavaScript nicht im Traum zu denken war.

Heute hat sich dieses Bild etwas gewandelt. Zum einem hat sich Java immer mehr als professionelle Programmiersprache etabliert, mit der man nicht nur kleine Applets für Webseiten, sondern auch echte Programme schreiben kann. Zum anderen können viele Webseiten-Elemente, die früher nur mit Java-Applets befriedigend zu realisieren waren, heute mit Hilfe alternativen, einfacher zu erlernenden Technologien (JavaScript, PHP, Flash, etc.) implementiert werden. Trotzdem ist Java nach wie vor eine Schlüsseltechnologie für die Erstellung dynamischer Webseiten, so dass wir Ihnen eine fundierte Einführung in die Erstellung und Nutzung von Applets nicht vorenthalten wollen.

Die Themen heute

15.1 Das Applet-Konzept

Bevor wir zu den Applets kommen, möchte ich noch ein paar allgemeine Worte zu Java verlieren.

Java und der Bytecode

In der Einführung zu JavaScript haben wir bereits angesprochen, dass ausführbare Programme aus einer Folge von in Bitfolgen codierten Maschinencode bestehen. Der vom Programmierer verfasste Quellcode eines Programms muss daher mit Hilfe eines Interpreters oder Compilers in Maschinencode umgewandelt werden. Das Problem dabei ist, dass die verschiedenen Plattformen (Kombinationen aus Prozessorarchitektur und Betriebssystem: Microsoft Windows/Intel, UNIX/Sparc, MacOS/PowerPC, etc.) unterschiedlichen Maschinencode benötigen.

Was bedeutet dies für Java-Programme? Java wurde so konzipiert, dass es plattformunabhängig ist. Für Applets ist dies eine absolute Grundvoraussetzung. Wenn Sie ein Applet in eine Webseite einbauen, müssen Sie ja davon ausgehen, dass Ihre Webseiten von Websurfern angefordert werden, die ganz unterschiedliche Rechnerarchitekturen verwenden (manche Websurfer haben Linux-PCs, andere Windows- oder Mac-Rechner).

Daraus folgt, dass Java-Programme interpretiert werden müssen.

Java-Interpreter kann man sich von der Website http.//java.sun.com herunterladen. Die großen Browser verfügen bereits über eingebaute Java-Interpreter.

Die Interpretation der Programme bringt aber auch Nachteile mit sich:

Aus diesem Grunde werden Java-Programme auch kompiliert.

Nanu? Java-Programme werden kompiliert und interpretiert? Wie soll das denn gehen? Nun ganz einfach: Der Java-Programmierer lässt das fertige Programm vom Java-Compiler in einen allgemeinen, plattformunabhängigen Maschinencode - den sogenannten Bytecode - übersetzen. Diesen Code liefert er aus. Der Anwender übergibt diesen Bytecode dem Java-Interpreter, der daraus plattformspezifischen Code erzeugt und diesen ausführt. Der Zwischenschritt mit dem Bytecode hat den Vorteil, dass die Interpretation schneller abläuft und die Anwender statt des Quelltextes nur kryptischen Binärcode zu Gesicht bekommen.

Abbildung 15.1:  Erstellung und Ausführung von Java-Programmen

Erstellung und Ausführung von Applets

Begleiten wir doch einmal ein Applet von seiner Erstellung im Editor des Programmierers bis zur Ausführung im Browser eines Websurfers.

  1. Alles beginnt damit, dass irgendein Programmierer oder Webdesigner in seinem Texteditor den Quelltext des Applets aufsetzt und diesen als Textdatei mit der Extension .java abspeichert.

Der Applet-Quelltext muss in einer eigenen Datei abgespeichert werden, er kann nicht wie JavaScript-Code direkt in den HTML-Code der Webseite eingefügt werden.

  1. Dann ruft der Programmierer den Java-Compiler auf und übergibt ihm die Quelltextdatei. Ist der Quelltext ohne Fehler, erzeugt der Compiler eine Bytecode- Datei mit der Extension .class.
  2. Als Nächstes bearbeitet der Programmierer/Webdesigner die Webseite, in die das Applet eingebettet werden soll. Dazu verwendet er das HTML-Tag <applet> oder <object>.

In den HTML-Tags gibt man Namen und Ort des Applets an. Im einfachsten Fall kopiert man die CLASS-Datei des Applets direkt in das Verzeichnis, in dem auch die Webseite steht, in der das Applet aufgerufen wird.

Jetzt machen wir einen Sprung und wechseln zu einem Websurfer, der gerade die Webseite mit dem Applet angesteuert hat.

  1. Der Browser lädt die Webseite. Der Webserver schickt ihm neben dem HTML-Code der Webseite und den eingebetteten Bildern auch die class-Datei des Applets.
  2. Der Websurfer scrollt den Inhalt der Webseite, bis er zu der Stelle kommt, an der das Applet eingebettet ist.
  3. Jetzt ruft der Browser den Java-Interpreter auf (vorausgesetzt er verfügt über einen integrierten Java-Interpreter und die Ausführung von Applets ist nicht deaktiviert) und startet das Applet.

Java und die Sicherheit des Client-Rechners

Wie schon bei JavaScript haben wir auch hier den Fall, dass fremder Code auf dem Rechner der Websurfer ausgeführt wird. Und wieder ist es vor allem der Interpreter, der sicherstellt, dass der Code, in diesem Fall das Applet, auf dem Client-Rechner keinen Schaden anrichten kann. Java-Programmierer sprechen in diesem Zusammenhang von der sandbox, dem »Sandkasten«, in dem sich das Applet tummeln kann, ohne Bereiche außerhalb dieses Sandkastens (andere laufende Anwendungen, Daten auf der Festplatte, etc.) gefährden zu können.

Hierin unterscheiden sich die Applets übrigens auch von den ActiveX-Elementen, die unter MS Windows-Programmierern recht beliebt sind. Diese werden bei Ausführung auf dem Client-Rechner quasi zu einer Erweiterung des Betriebssystems und unterliegen kaum irgendwelchen Beschränkungen.

15.2 Eigene Applets erstellen

Es ist Zeit, mal wieder ein bisschen zu programmieren. Doch bevor wir loslegen können, müssen Sie noch den Java-SDK, die Java-Entwicklungsumgebung von Sun herunterladen und installieren - nicht wegen dem Interpreter (der ist vermutlich bereits in Ihren Browser integriert), sondern wegen des Compilers und den Java-Bibliotheken.

Die Java-Entwicklungsumgebung

Die aktuelle Version finden Sie jeweils auf der Website http://java.sun.com, derzeit ist es Java 2, Version 1.3. Laden Sie den SDK herunter und installieren Sie ihn wie auf der Website beschrieben.

Abbildung 15.2:  Die Java-Website von Sun

Zur Entwicklungsumgebung gehören neben den Java-Bibliotheken und einigen Beispielen vor allem die Kommandozeilenwerkzeuge zum Erstellen und Testen der Java-Programme. Diese Programme verfügen über keine grafische Benutzeroberfläche und können nur von der Konsole (Terminal-Fenster) ausgeführt werden.

Die Windows-Konsole

Im Gegensatz zu Linux-Anwendern wissen viele Windows-Anwender schon gar nicht mehr, was eine Konsole ist.

Unter Windows heißt die Konsole meist MSDOS-Eingabeaufforderung oder ähnlich und kann über das Start/Programme-Menü aufgerufen werden. Die Konsole ist rein textbasiert, das heißt sämtliche auszuführenden Befehle müssen Sie über die Tastatur eintippen.

Nach Aufruf der Konsole befinden Sie sich zuerst einmal im Windows-Verzeichnis, beispielsweise C:\Windows. Wenn wir später unsere Java-Programme kompilieren, müssen Sie von dort in das Verzeichnis wechseln, in dem die Quelldatei des Java-Programms steht. Dazu dient der Befehl cd.

¯ Mit cd .. wechseln Sie in das übergeordnete Verzeichnis.

¯ Mit cd einVerzeichnis wechseln Sie in ein untergeordnetes Verzeichnis namens »einVerzeichnis«.

¯ Wenn Sie in dem Verzeichnis mit dem Java-Programm angekommen sind, können Sie sich die in dem Verzeichnis enthaltenen Dateien und Unterverzeichnisse durch Eingabe des Befehls dir (beziehungsweise dir /p für seitenweise Anzeige) anschauen.

Beachten Sie, dass die Konsole lange Dateinamen (mehr als 8 Zeichen ohne Extension) nicht vollständig unterstützt. Wundern Sie sich also nicht, wenn Sie verkrüppelte Namen mit einer Tilde ~ sehen.

  1. Rufen Sie jetzt einmal Ihre Konsole auf.
  2. Geben Sie am Eingabeprompt javac ein und schicken Sie den Befehl durch Drücken der (Return)-Taste ab.

javac ist der Java-Compiler. Wenn Sie eine Fehlermeldung erhalten haben, dass der Befehl oder das Programm nicht verfügbar ist, liegt dies daran, dass Ihr System nicht so eingerichtet ist, dass Sie die Java-Werkzeuge von jedem beliebigen Verzeichnis aus aufrufen können. Durchsuchen Sie jetzt Ihre Festplatte nach dem Verzeichnis, in dem javac.exe installiert ist. Wenn Sie die Java-Entwicklungsumgebung unter C:\Java installiert haben, könnte das Verzeichnis beispielsweise C:\Java\jdk2\bin lauten. Wenn Sie jetzt am Prompt zuerst den Pfad zu dem Compiler und dann den Compilernamen eingeben (C:\Java\jdk2\bin\javac), müssten Sie als Antwort eine Beschreibung der Aufrufsyntax für den Compiler sehen.

Immer den Pfad mit angeben zu müssen, ist recht lästig. Bequemer ist es, den Pfad zum Compiler und den anderen Java-Werkzeugen in Ihren Systempfad einzutragen.

Nachdem Sie den Computer neu gestartet haben (unter Unix/Linux reicht es, aus- und neu einzuloggen), sollten die Java-Werkzeuge von jedem Verzeichnis aus verfügbar sein (siehe Abbildung 15.3).

Abbildung 15.3:  javac wurde gefunden

Ein einfaches Applet

Anhand eines möglichst einfachen Beispiels wollen wir uns nun mit dem Prozess der Applet-Erstellung vertraut machen. Der Code für ein minimales Applets sieht wie folgt aus.

Listing 15.1: HalloWWW.java

// Dies ist das erste Applet 

import java.awt.Graphics;
import java.applet.Applet;

public class HalloWWW extends Applet
{
public void paint(Graphics gc)
{
gc.drawString("Hallo World Wide Web!",100,50);
}
}

Versuchen wir zu verstehen, wie dieser Code aufgebaut ist. Lassen Sie sich aber nicht verdrießen, wenn nicht alles klar wird. Java ist eine äußerst leistungsfähige und damit auch eine recht komplexe Programmiersprache. Zudem ist Java rein objektorientiert, was bedeutet, dass sich der Programmierer von Anfang an mit einer Reihe von nicht leicht zu verstehenden, objektorientierten Konzepten auseinandersetzen muss (die Objektorientierung reicht in Java überdies viel weiter, als wir es von JavaScript her kennen). Es wäre also ziemlich vermessen, Java an einem einzigen Tag erlernen zu wollen. Wir beschränken uns daher auf die Vorstellung der wichtigsten Konzepte und einiger ausgesuchter Techniken und Syntaxelemente. Dies sollte ausreichen, eigene Ideen für Applets zu realisieren. Wer sich gründlicher und systematischer in Java einarbeiten möchte, der sei an die entsprechende Fachliteratur verwiesen (siehe Anhang E).

Kommentare

Am Anfang unseres Java-Applets steht ein Kommentar. Alle Zeichen einer Zeile, die nach dem // erscheinen, werden von dem Java-Compiler als Kommentar angesehen und ignoriert, da sie nur für den Programmierer als Gedächtnisstütze dienen sollen. Bei kleinen Programmen sind Kommentare noch nicht so wichtig, aber bei etwas größeren Programmierprojekten sind sie unverzichtbar, damit der Programmierer oder andere, die den Code lesen wollen, nachvollziehen können, was das Programm an der jeweiligen Stelle macht.

Mehrzeilige Kommentare kann man mit Hilfe der »Klammern« /* und */ einfügen:

/* Dies ist
alles
Kommentar */

Die Hauptklasse des Applets

Die nächsten Zeilen des Beispiels sehen schon ziemlich wild aus und wir werden uns langsam von außen nach innen vorarbeiten.

import java.awt.Graphics;
import java.applet.Applet;

public class HalloWWW extends Applet
{

}

Hier wird eine Klasse2 mit dem Namen HalloWWW definiert. Da Java rein objektorientiert ist, bestehen Java-Programme praktisch nur aus Klassendefinitionen. Das muss man erst einmal wirken lassen. In Java kann man Anweisungen nicht wie in JavaScript frei in den Quelltext schreiben. In Java gibt es auch keine Funktionen, sondern nur Methoden (Funktionen, die Teil einer Klasse sind). Wenn wir also mit Java programmieren, definieren wir Klassen mit Datenelementen und Methoden und schreiben alle auszuführenden Anweisungen in die Methoden der Klasse.

Die Definition einer Klasse beginnt mit dem Schlüsselwort class, gefolgt von dem Namen der neuen Klasse (in diesem Beispiel HalloWWW).

class HalloWWW
{
}

In den Java-Bibliotheken gibt es viele fertige Klassen, die von Java bereitgestellt werden. Eine solche Klasse ist die Klasse Applet, die eine Reihe von Methoden enthält, die für die Applet-Programmierung wichtig sind: paint(), init(), start(), stop() und destroy(). Damit wir diese Methoden auch für unsere Applet-Klasse HalloWWW nutzen können, geben wir Applet als Basisklasse unserer Applet-Klasse an.

Tatsächlich wird unser Programm überhaupt erst dadurch zu einem Applet, dass wir die Hauptklasse des Programms von der Basisklasse Applet ableiten.

class HalloWWW extends Applet
{
}

Das Schlüsselwort extends teilt dem Compiler mit, dass unsere Klasse HalloWWW alle Elemente der angegebenen Basisklasse (Applet) erben soll.

Jetzt gibt es nur noch ein Problem. Die Java-Bibliotheken sind sehr umfangreich und enthalten einige hundert Klassen. Würde der Compiler den Programmen automatisch alle Klassen aus diesen Bibliotheken zur Verfügung stellen, müsste er für jedes Programm standardmäßig Hunderte von Namen verwalten. Aus diesem Grunde stellt der Compiler nur einige wenige Klassen automatisch zur Verfügung, den Rest muss man explizit importieren. Dies geschieht mit Hilfe der import-Anweisungen am Anfang des Programms:

import java.awt.Graphics;
import java.applet.Applet;

class HalloWWW extends Applet

}

Die Klassen der Java-Bibliothek sind in Paketen (englisch packages) organisiert. Benötigt man mehrere Klassen eines solchen Pakets braucht man die Klassen nicht einzeln zu importieren. Mit Hilfe des *-Zeichens kann man alle Klassen eines Pakets auf einmal importieren. So importiert beispielsweise die Anweisung import java.awt.* alle Klassen aus dem awt-Paket.

Zu guter Letzt müssen wir der Klassendeklaration noch das Schlüsselwort public voranstellen:

import java.awt.Graphics;
import java.applet.Applet;

public class HalloWWW extends Applet

}

Das Schlüsselwort public ist einer von drei Zugriffsmodifizierer (public, protected, private), die regeln, inwieweit andere Teile des Codes auf diese Klasse zugreifen können. Die Hauptklasse eines Applets muss unbedingt mit dem Modifizierer public deklariert werden - sonst hätte der Browser keine Berechtigung das Applet, das er mit der Webseite geladen hat, auszuführen.

Die Applet-Methoden

Auch wenn es vielleicht gar nicht so aussieht, aber unsere Klasse HalloWWW enthält jetzt - dank der Ableitung von der Klasse Applet - tatsächlich bereits fünf Methoden namens paint(), init(), start(), stop() und destroy(). Und das ist auch gut so, denn wenn der Browser das Applet ausführt, ruft er genau diese Methoden auf:

Unser Applet ist jetzt zwar funktionsfähig, aber es macht noch nichts. Um es zum Leben zu erwecken, überschreiben wir die von der Basisklasse Applet geerbten Methoden (in diesem Abschnitt begnügen wir uns damit, die paint()-Methode zu überschreiben).

Methoden überschreiben

Eine Methode zu überschreiben, bedeutet, die Signatur der Methode (Name, Parameter, Rückgabewert) zu übernehmen und mit einem neuen Anweisungsteil zu verbinden. Die paint()-Methode, die wir von der Basisklasse Applet gerbt haben und die der Browser zum Zeichnen des Applets aufruft, hat beispielsweise folgende Signatur:

void paint(java.awt.Graphics gc)

Indem wir diese Methode mit einem eigenen Anweisungsteil versehen, können wir steuern, wie das Applet im Browser aussehen soll. Zuvor sollten wir aber noch ein paar Worte zu obiger Methodensignatur verlieren. (Wir haben Sie gewarnt: selbst einfachste Java-Programme konfrontieren den Programmierneuling mit einer Flut an neuen Konzepten.)

Datentypen in Java

Java ist - im Gegensatz zu JavaScript - eine streng typisierte Sprache. Das bedeutet, dass jede Variable, jede Methode und jede Klasse, die wir verwenden wollen, vorab deklariert3 werden muss und dass zu jeder Deklaration einer Variablen, eines Methodenparameters oder eines Methodenrückgabewertes ein Datentypangabe gehört. Dabei unterscheidet Java zwischen

Elementare Datentypen sind beispielsweise Ganzzahlen, einzelne Zeichen, Boolesche Werte (siehe Tabelle 15.1).

Datentyp

Beschreibung

Wertebereich

Literal

boolean

Boolescher Wert

true, false

true, false

char

Zeichen, Buchstabe

Unicode-Werte

'c'

byte

ganze Zahl

-128 bis +127

12

short

ganze Zahl

-32768 bis 32767

12

int

ganze Zahl

-2.147.483.648
bis +2.147.483.647

12

0xC

long

ganze Zahl

-9.223.372.036.854.775.808
bis 9.223.372.036.854.775.807

12L

float

Fließkommazahl

-3,40282347E+38
bis +3,40282347E+38

12.5f

1e5f

double

Fließkommazahl

-1,7976931348623157E+308
bis +1,7976931348623157E+308

12.5

1e5

void

kein Datentyp

-

-

Tabelle 15.1: Elementare Datentypen in Java

Variablen von elementaren Datentypen tauchen in Java-Programmen nur als Datenelemente von Klassen, als Parameter von Methoden oder als Rückgabewerte von Methoden auf.

Die zusammengesetzten Datentypen sind nichts anderes als die uns bekannten Klassen. Jede Klassendefinition definiert auch einen neuen Datentyp. Objekte einer Klasse sind daher »Variablen« vom Typ ihrer Klasse. (Wobei es keinen Unterschied macht, ob die Klasse aus der Java-Bibliothek stammt oder von Ihnen im Programm neu definiert wurde.)

Mit diesem Hintergrundwissen können wir die Signatur der paint()-Methode etwas besser verstehen:

void paint(java.awt.Graphics gc).

paint() ist eine Methode, die einen einzigen Parameter (dem wir hier den Namen gc gegeben haben) vom Typ der Klasse java.awt.Graphics definiert. Ihr Rückgabetyp ist void, was besagt, dass die Methode keinen Wert zurückliefert.

Die paint()-Methode

Zurück zu unserem Applet-Code. Dort wurde die paint()-Methode wie folgt überschrieben:

public void paint(Graphics gc)
{
gc.drawString("Hallo World Wide Web!",100,100);
}

Denken Sie daran, dass die paint()-Methode vom Browser aufgerufen wird. Dieser übergibt ihr ein Objekt vom Typ der Klasse java.awt.Graphics, das den Teil der Webseite repräsentiert, den das Applet einnimmt. (Dass wir beim Überschreiben Graphics statt java.awt.Graphics schreiben können, liegt daran, dass wir weiter oben java.awt.Graphics importiert haben.)

Der Parameter gc repräsentiert jetzt für uns eine Art Leinwand, in die wir mit Hilfe der Methoden der Klasse Graphics zeichnen können. Alle Zeichenoperationen, die wir auf gc ausführen, werden sofort im Applet sichtbar.

Im obigen Beispiel begnügen wir uns damit, einen Text in das Applet zu zeichnen. Dazu dient die Methode gc.drawString(), die als Parameter die einzuzeichnende Zeichenkette »Hallo World Wide Web!« erhält sowie die x- und y-Koordinaten der Stelle, an der der Text angezeigt werden soll.

Rekapitulieren wir

Das Grundgerüst eines Java-Applets besteht aus einer Hauptklasse, die von der vordefinierten Klasse java.applet.Applet abgeleitet und als public deklariert wird.

import java.applet.Applet;
public class KLASSENNAME extends Applet
{
}

Von der Basisklasse Applet erbt die Hauptklasse die Methoden: paint(), init(), start(), stop() und destroy(). Will man etwas in den Bereich, den das Applet in der Webseite einnimmt, ausgeben, überschreibt man die geerbte paint()-Methode und zeichnet die Ausgabe in den gc-Parameter.

Achten Sie bei allen Schlüsselwörtern und Bezeichnern (Namen von Klassen, Packages, Methoden, Variablen) auf die Groß- und Kleinschreibung!

Applets kompilieren

Um dieses - und jedes andere - Applet auf Ihrem Computer zu erstellen und auszuführen, gehen Sie wie folgt vor:

  1. Rufen Sie einen beliebigen Texteditor auf, mit dem Sie Ihren Quellcode als ASCII- Text abspeichern können.
  2. Öffnen Sie ein neue Datei, tippen Sie Ihren Quelltext ein und speichern Sie die Datei unter den Namen der Applet-Klasse und mit der Dateiextension .java.

Dies ist ganz wichtig. Wenn die Applet-Klasse, wie in unserem Beispiel HalloWWW heißt, muss die Datei unter den Namen HalloWWW.java abgespeichert werden, wobei sogar die Groß- und Kleinschreibung zu berücksichtigen ist.

  1. Öffnen Sie jetzt ein Konsolenfenster (siehe 15.2.1) und wechseln Sie zu dem Verzeichnis, in dem Sie die .java-Quelldatei abgespeichert haben.
  2. Rufen Sie den Java-Compiler javac mit dem Namen der Quelldatei auf:
    :> javac HalloWWWW.java

Applets in Webseiten einbinden

Bevor wir das Applet ausführen und austesten können, müssen wir noch eine passende HTML-Seite aufsetzen, die das Applet aufruft.

Listing 15.2: HalloWWW.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Erstes Applet</title>
</head>

<body>

<p>Webseite ruft Applet. Bitte antworten.</p>

<applet code="HalloWWW.class" width="300" height="100"></applet>

</body>
</html>

Hier wird das Applet mit Hilfe des <applet>-Tags eingebettet. Das ist derzeit immer noch gängige Praxis, obwohl das <applet>-Tag seit HTML 4 als deprecated eingestuft ist und eigentlich nicht mehr verwendet werden sollte. Statt dessen empfiehlt der Standard das <object>-Tag. Die Einbettung von Applets mit dem <object>-Tag (siehe unten), wird derzeit aber nur vom Netscape 6-Browser unterstützt. Man ist also gut beraten, im Augenblick noch dem <applet>-Tag den Vorzug zu geben.

Notwendige Attribute für das <applet>-Tag sind:

Wenn das Applet nicht im gleichen Verzeichnis wie das HTML-Dokument steht (genauer gesagt, nicht im aktuellen Verzeichnis), müssen Sie im codebase-Attribut den absoluten oder relativen Pfad zur Applet-Datei angeben. Wenn beispielsweise die HTML-Datei im Verzeichnis c:\meinServer\html steht und der Appletcode im Verzeichnis c:\meinServer\applets, dann wird codebase folgendermaßen gesetzt:

<applet code="HalloWWW.class" 
codebase="../applets"
widht="100" height="80">
</applet>

Optional kann man mit dem align-Attribut die Ausrichtung des Applets im umgebenden Text steuern:

Ausrichtung

Beschreibung

align="left"

Ausrichtung zum linken Rand hin

align="right"

Ausrichtung zum rechten Rand hin

align="top"

Ausrichtung nach dem größten Element der Zeile

align="middle"

Ausrichtung der Zeile an der Mitte des Applets

align="bottom"

Ausrichtung der Zeile am unteren Ende des Applets

Tabelle 15.2: Ausrichtungsmöglichkeiten für Applets

Das <object>-Tag

Mit Hilfe des <object>-Tags sähe die Einbettung des Applets wie folgt aus:

<p>
<object codetype="application/java" classid="java:HalloWWW.class"
width="300" height="100">
Sorry, Ihr Browser unterstützt keine Java-Applets.</object>
</p>

Derzeit unterstützt aber wie gesagt nur der Netscape 6-Browser diese Syntax. (Dafür hapert es bei ihm mit dem korrekten Neuzeichnen der Applets - jedenfalls galt dies für das erste Release des Browsers.)

  1. Speichern Sie den HTML-Code der Webseite unter einem beliebigen Namen (wir haben die HTML-Datei nach dem Applet benannt) in dem gleichen Verzeichnis wie das Java-Applet.
  2. Laden Sie die HTML-Datei in Ihren Browser.

    Abbildung 15.5:  Das Applet im Internet Explorer

15.3 Parameter an Applets übergeben

Aus der Arbeit mit Funktionen und Methoden wissen Sie, dass man Funktionen oder Methoden, die Daten verarbeiten, in vielen Fällen vielseitiger einsetzen kann, wenn die Daten als Parameter übergeben werden. So wäre eine drawString-Methode, die immer den gleichen Text ausgibt, ziemlich nutzlos (außer man will ausgerechnet diesen einen Text ausgeben). Eine drawString-Methode, die einen beliebigen Text ausgibt, den man als Argument beim Aufruf übergibt, ist dagegen sehr vielseitig verwendbar.

Gleiches gilt für Applets. Aber wer könnte überhaupt den Parametern eines Applets Argumente übergeben? Richtig, die Webseite - oder genauer gesagt, der HTML-Code, der das Applet einbettet.

Parameter an Applets werden mit dem <param>-Tag übergeben (das zusammen mit dem <applet> wie auch dem <object>-Tag verwendet werden kann). Es können beliebig viele Parameter angegeben werden. Jeder einzelne Parameter ist durch seinen Parameternamen (name-Attribut) und einen Wert (value-Attribut) definiert.

Die Webseite aus Listing 15.3 bettet ein Applet namens Parameter.class ein und übergibt ihm einen Text, den das Applet ausgeben soll.

Listing 15.3: Parameter.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Erstes Applet</title>
</head>

<body>

<p>Webseite ruft Applet. Bitte antworten.</p>

<applet code="Parameter.class" width="300" height="100">
<param name="text" value="Hallo vom Applet" />
</applet>

</body>
</html>

Jetzt müssen wir noch das dazugehörige Applet aufsetzen, das diesen Parameter einliest und verarbeitet.

Listing 15.4: Parameter.java

// Parameterübergabe für Applets 

import java.awt.Graphics;
import java.applet.Applet;

public class Parameter extends Applet
{
public void paint(Graphics gc)
{
String str;

str = getParameter("text");
gc.drawString(str,100,50);
}
}

Obiges Listing ist eine einfache Erweiterung des HalloWWW.java-Listings. Da wir die Quelldatei unter einem anderen Namen abgespeichert haben (Parameter.java) müssen wir auch den Namen der Hauptklasse ändern.

Nicht vergessen! Der Name der .java-Datei und der Name der Hauptklasse des Applets müssen identisch sein (einschließlich Berücksichtigung der Groß- und Kleinschreibung).

Der eigentliche Code zur Entgegennahme und Verarbeitung des HTML-Parameters erfolgt in der paint()-Methode. Zuerst deklarieren wir eine String-Variable, in der wir das vom HTML-Code übergebene Argument abspeichern wollen. Java kennt keinen elementaren Datentyp für Strings (der Datentyp char ist nur für einzelne Zeichen). Als Ersatz gibt es in den Java-Bibliotheken eine eigene Klasse String, mit der man Text bearbeiten kann.

String str;

erzeugt also ein Objekt str vom Typ der Klasse String.

Als Nächstes nehmen wir den HTML-Parameter entgegen. Dazu rufen wir die Methode getParameter() auf. Wo kommt diese Methode her? Wir haben Sie zusammen mit den anderen Applet-Methoden (paint(), init(), start(), etc.) von der Basisklasse Applet geerbt.

Da die Methode getParameter() bereits in der Basisklasse so definiert wurde, dass sie einzelne Argumente vom HTML-Code entgegen nimmt und als Ergebnis zurückliefert, gibt es für uns keinen Grund diese Methode zu überschreiben (wie wir es mit paint() getan haben. Wir rufen Sie also einfach auf.

Methodenaufrufe mit und ohne Objekt

Vielleicht fragen Sie sich jetzt, warum getParameter() einfach so aufgerufen werden kann, während wir die Methode drawString() über das Objekt gc aufrufen müssen?

Grundsätzlich gilt: Wenn Sie in einer Methode einer Klasse A eine andere Methode der Klasse A aufrufen wollen, brauchen Sie dafür kein Objekt. Sie rufen die Methode einfach auf. Wenn Sie dagegen in einer Methode einer Klasse A eine Methode einer anderen Klasse B aufrufen wollen (wie im Falle der Graphics-Methode drawString(), die wir in der Applet-Methode paint() aufrufen), brauchen Sie ein Objekt der anderen Klasse B.

Zurück zu unserem Applet.

Wenn wir die Methode getParameter() aufrufen, übergeben wir ihr als Argument den Namen des HTML-Parameters, den die Methode zurückliefern soll. In unserem Beispiel heißt der Parameter "text". Dafür liefert uns die Methode den Wert des value-Attributs dieses Parameters.

Wir speichern den Wert in unserem str-Objekt und geben dieses wie gehabt aus:

    str = getParameter("text");
gc.drawString(str,100,50);

Nachdem Sie den Quelltext des Applets kompiliert haben, können Sie die zugehörige Webseite in Ihren Browser laden und das Applet testen.

Abbildung 15.6:  Ausgabe von Text, der als HTML-Parameter übergeben wurde

Die Methode getParameter() liefert die Werte der HTML-Parameter immer als Strings zurück. Wenn Sie Zahlen als Argumente übergeben wollen, müssen Sie den zurückgelieferten String erst in die entsprechende Zahl umwandeln. Des geschieht mit Hilfe spezieller Methoden:

Sting str;
int param1;
str = getParameter("Param1");
param1 = Integer.valueOf(str).intValue();

Die init()-Methode

Obiges Beispiel hat einen kleinen Makel. Die paint()-Methode wird jedes Mal aufgerufen, wenn der Browser entscheidet, dass das Applet neu gezeichnet werden muss. Dies ist zum Beispiel der Fall,

Unschön ist, dass dabei jedes Mal der HTML-Parameter abgefragt wird. Effizienter wäre es, den Parameter (der sich ja nicht ändert) nur einmal, beim Laden der Webseite, abzufragen. Dazu brauchen wir nur die geerbte init()-Methode zu überschreiben.

Listing 15.5: Parameter2.java

// Parameterübergabe für Applets 

import java.awt.Graphics;
import java.applet.Applet;

public class Parameter2 extends Applet
{
String str;

public void init()
{
str = getParameter("text");
}

public void paint(Graphics gc)
{
gc.drawString(str,100,50);
}
}

Hier wird der HTML-Parameter in der init()-Methode abgefragt und in der paint()- Methode ausgegeben. Damit das str-Objekt in beiden Methoden verfügbar ist, müssen wir es als Datenelement am Anfang der Klassendefinition deklarieren.

Variablen, die am Anfang einer Klassendeklaration definiert werden, können von allen Methoden der Klasse benutzt werden (im Gegensatz zu lokalen Variablen, die in einer Methode definiert werden und nur in dieser Methode verwendet werden können). Man bezeichnet sie auch als Instanzvariablen.

15.4 Grafikausgaben in Applets

Wenn ein Applet in eine Webseite eingefügt wird, wird ihm vom HTML-Code durch die <applet>-Argumente width und height eine begrenzte Fläche zur freien Verfügung gestellt. Diese Fläche ist quasi Benutzeroberfläche und Ausgabefläche unseres Applets. In der paint()-Methode können wir in diese Fläche zeichnen.

Die paint()-Methode

Warum erzeugt man die Ausgaben eines Applets gerade in paint() und nicht in einer beliebigen anderen Methode des Applets?

Nun, grundsätzlich kann man tatsächlich von jeder Applet-Methode aus in das Applet zeichnen. Die paint()-Methode bietet aber zwei wichtige Vorteile:

Die Zeichenmethoden

Alle Zeichenmethoden, die wir benötigen, sind in der Klasse Graphics definiert.

Methode

Beschreibung

clearRect(int, int, int, int)

Füllt den spezifizierten Bereich mit der Hintergrundfarbe.

drawArc(int, int, int, int,
int, int)

Zeichnet einen Bogen ein.

drawImage(Image,int, int,
ImageObserver)

Zeichnet ein Bild an die spezifizierte Position (= linke obere Ecke).

drawLine(int, int, int, int)

Zeichnet eine Linie ein.

drawOval(int, int, int, int)

Zeichnet ein Oval ein.

drawPolygon(int[], int[],
int)

Zeichnet ein Polygon ein.

drawPolyline(int[], int[],
int)

Zeichnet einen Linienzug ein.

drawRect(int, int, int, int)

Zeichnet ein Rechteck ein.

drawRoundRect(int, int, int, 
int, int, int)

Zeichnet ein Rechteck mit abgerundeten Ecken ein.

drawString(String, int, int)

Gibt einen String an der spezifizierten Koordinate aus.

fillArc(), fillOval(), fillPolygon(), fillRect() ...

Eine Reihe von Methoden zum Zeichnen ausgefüllter Formen (vgl. draw...()).

Color getColor()

Liefert die aktuelle Zeichenfarbe zurück.

Font getFont()

Liefert die aktuell verwendete Schriftart zurück.

setColor(Color)

Definiert die beim Zeichnen zu verwendende Farbe.

setFont(Font)

Definiert die zu verwendende Schriftart.

Tabelle 15.3: Auswahl einiger Methoden der Klasse Graphics

Was kann man mit diesen Methoden anfangen? Nun, eine ganze Menge. Sie müssen nur noch wissen, dass

und schon kann es losgehen.

Das Flecken-Applet

Das Applet zu diesem Abschnitt ist ein einfacher Fleckengenerator, dass sieben Flecke einer Farbe, aber unterschiedlicher Radien und Mittelpunkte ausgibt. Wir wollen das Applet so implementieren, dass die Farbe beim Laden des Applets und die Radien und Mittelpunkte der Flecke beim Starten festgelegt werden.

Wir beginnen damit, dass wir in der Applet-Klasse eine untergeordnete Hilfsklasse namens Scheibe definieren. Diese Klasse verfügt über Instanzvariablen, in denen man den Mittelpunkt und den Radius eines einzelnen Flecks speichern kann.

Listing 15.6: Spot.java

// Der Fleckengenerator
import java.awt.*;
import java.applet.*;

public class Spot extends Applet
{
class Scheibe
{
int m_x, m_y; // Mittelpunkt
int m_r; // Radius
}

Scheibe[] m_flecken; // Array von Scheibe-Objekten
Color m_farbe;

Unter der Hilfsklasse Scheibe haben wir ein Array-Objekt namens m_flecken erzeugt. Da das Array-Objekt mit dem Datentyp Scheibe deklariert wurde, kann man in dem Array auch nur Objekte vom Typ Scheibe abspeichern (geschieht in der init()-Methode).

Als zweite Instanzvariable der Klasse Spot haben wir m_farbe definiert. m_farbe ist vom Typ der vordefinierten Java-Klasse Color, und wir werden in ihr die Farbe für die Flecken speichern.

Nachdem die Instanzvariablen deklariert sind, kommen wir zur init()-Methode.

  public void init()
{
// Flecken erzeugen
m_flecken = new Scheibe[7];
for(int i = 0; i < m_flecken.length; i++)
{
m_flecken[i] = new Scheibe();
}

//Farbe festlegen
m_farbe = new Color((int) (255*Math.random()),
(int) (255*Math.random()),
(int) (255*Math.random()) );
}

Wir beginnen damit, dass wir der Instanzvariablen m_flecken einen Wert zuweisen. m_flecken erwartet als »Wert« ein Array-Objekt. Objekte von Klassentypen werden in Java immer mit Hilfe des new-Operators und des Konstruktors der Klasse erzeugt.

Konstruktoren

Der Konstruktor ist eine spezielle Methode der Klasse, die den gleichen Namen wie die Klasse trägt und immer dann aufgerufen wird, wenn ein Objekt der Klasse erzeugt wird. (Tatsächlich kann der Konstruktor nur zur Erzeugung von Objekten aufgerufen werden.) Falls eine Klasse keinen eigenen Konstruktor definiert, weist ihr der Java-Compiler einen Standardkonstruktor zu.

Die Anweisung

m_flecken = new Scheibe[7];

erzeugt also ein Array-Objekt, das sieben Scheibe-Objekte aufnehmen kann, und weist dieses Objekt der Instanzvariablen m_flecken zu.

Damit haben wir aber noch nicht die einzelnen Scheibe-Objekte erzeugt. Dies geschieht in der anschließenden for-Schleife.

for- und while-Schleifen funktionieren in Java ganz so wie in JavaScript (siehe Kapitel 9.3).

Zum Schluss erzeugt die init()-Methode ein neues Color-Objekt und speichert es in der Instanzvariablen m_farbe.

Farbobjekte werden - wie in vielen Programmiersprachen üblich - als RGB-Farben definiert, das heißt man mischt die Farbe aus Rot-, Grün- und Blau-Anteilen zusammen. Jeder Farbanteil bekommt dabei einen Werte zwischen 0 (kein Farbanteil) und 255 (voller Farbanteil) zugewiesen. Die Mischung erfolgt nach dem Prinzip der Lichtfarben, das heißt, Color(255, 255, 255) wäre Weiß. (Für die wichtigsten Farben gibt es vordefinierte Werte: Color.black, Color.red, etc.)

Jetzt müssen wir noch festlegen, wo die Flecken eingezeichnet werden sollen und wie groß sie sein sollen. Den Code hierfür setzen wir in der start()-Methode auf (obwohl man ihn auch in init() einfügen könnte).

  public void start()
{
//Mittelpunkte und Radien festlegen
for(int i = 0; i < m_flecken.length; i++)
{
m_flecken[i].m_x = (int) (400*Math.random());
m_flecken[i].m_y = (int) (200*Math.random());
m_flecken[i].m_r = (int) (50*Math.random());
}
}

Zu guter Letzt geben wir die Flecken aus:

  public void paint(Graphics gc)
{
gc.setColor(m_farbe);
for(int i = 0; i < m_flecken.length; i++)
{
gc.fillOval(m_flecken[i].m_x,
m_flecken[i].m_y,
m_flecken[i].m_r * 2,
m_flecken[i].m_r * 2);
}
}
} // Ende von Spot.java

Zuerst richten wir mit Hilfe der Graphics-Methode setColor() den Farbwert in m_farbe als neue Zeichenfarbe ein.

gc.setColor(m_farbe);

Dann gehen wir in einer Schleife die einzelnen Scheibe-Objekte durch und zeichnen sie in das Applet.

Zum Zeichnen von ausgefüllten Scheiben verwendet man die Methode fillOval(). Dieser übergibt man als Argumente die Koordinaten der linken, oberen Ecke und die Breite und Höhe eines rechteckigen Ausgabebereichs. In diesen Ausgabebereich zeichnet die Methode die Scheibe formatfüllend ein. (Um kreisförmige Scheiben einzuzeichnen, übergibt man einfach gleiche Werte für Breite und Höhe.)

Listing 15.7: Spot.html - das HTML-Dokument zum Anzeigen des Applets

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Fleckenapplet</title>
</head>

<body>
<p>Dieses Dokument dient der Demonstration des Fleckengenerators.</p>

<hr />
<applet code="Spot.class" width="400" height="200"></applet>
<hr />

</body>
</html>

Abbildung 15.7:  Das Fleckenapplet im Internet Explorer

Das Applet testen

Nachdem Sie das Applet kompiliert haben, sollten Sie es in verschiedenen Browsern testen. Wenn Sie es beispielsweise in den Internet Explorer 5 oder den Netscape 6-Browser laden, können Sie sehen, dass bei jedem Aktualisieren (Neuladen) der Webseite die Farbe und die Positionen/Radien der Flecke neu festgelegt werden.

Wenn Sie die Webseite mit dem Applet dagegen in den Netscape Navigator 4 laden, und dann auf die Schaltfläche Neu laden drücken, werden Sie feststellen, dass sich nur die Position und die Größe der Flecken ändert, nicht aber die Farbe. Dies liegt daran, dass der Navigator 4 das Applet selbst nicht neu lädt, sondern nur die start()-Methode erneut aufruft. Soll das Applet ganz neu geladen (und init() aufgerufen) werden, müssen Sie den Neu laden-Schalter zusammen mit der (Shift)-Taste drücken.

Zum Testen können Sie die Webseite mit dem Applet auch in den Appletviewer des Java- SDK laden. Rufen Sie dazu den Appletviewer wie folgt von der Konsole aus auf:

prompt:> appletviewer spot.html

Im Appletviewer finden Sie dann eine Reihe von Schaltern, mit denen Sie das Starten, Stoppen oder Neuladen des Applets simulieren können.

15.5 Auf Mausklicks reagieren

Das Grundprinzip der Ereignisverarbeitung unter Java ist das gleiche wie unter JavaScript. Mit Maus und Tastatur löst der Anwender auf den verschiedenen Elementen eines Applets Ereignisse aus. Wurde für eines der ausgelösten Ereignisse eine Behandlungsmethode eingerichtet, wird der Code dieser Methode ausgeführt.

Die Frage ist nun, wie man eine solche Behandlungsmethode einrichten kann?

Zuerst überlegt man sich, für welches »Element« man welches Ereignis abfangen möchte. In Java kann man Ereignisse für das Applet oder für die im Applet enthaltenen Steuerelemente abfangen. Da wir über die Erzeugung und Einbindung von Steuerelementen in Java noch nichts gehört haben (und im Verlaufe dieses Buches auch nichts weiter erfahren werden, sorry!), werden wir uns ein Applet-Ereignis aussuchen.

Für die Applet-Programmierung sind besonders die Mausereignisse interessant (Klick mit der Maus, Maus wird über das Applet bewegt, etc.). Unter diesen Ereignissen greifen wir uns das Mausklickereignis heraus. Unser Ziel soll es sein, ein Applet zu implementieren, das Mausklicke abfängt und an der Stelle des Mausklicks eine Meldung ausgibt.

Die Ereignismethoden

Java hält für die verschiedenen Ereignisse eine Reihe von vordefinierten Methoden bereit. Diese Methoden sind in Interfaces und Adapter-Klassen organisiert. Der Einfachheit halber werden wir uns hier auf die Adapter-Klassen konzentrieren.

Die Adapter-Klassen für die Mausereignisse heißen MouseAdapter und MouseMotionAdapter.

Adapter-Klasse

Methoden

MouseAdapter

mouseClicked(MouseEvent)

mouseEntered(MouseEvent)

mouseExited(MouseEvent)

mousePressed(MouseEvent)

MouseMotionAdapter

mouseDragged(MouseEvent)

mouseMoved(MouseEvent)

Tabelle 15.4: Mausbehandlungsmethoden

Das Erste, was wir tun werden, ist daher die Methode mouseClicked zu überschreiben. Dazu sind drei Schritte nötig.

  1. Wir müssen die Adapter-Klassen in java.awt.event importieren.
    import java.awt.event.*;
  2. Wir müssen eine eigene Ereignislauscher-Klasse von MouseAdapter ableiten:
      class MeinMausLauscher extends MouseAdapter
    {
    }
  3. Wir müssen die Methode mouseClicked() überschreiben
      class MeinMausLauscher extends MouseAdapter
    {
    public void mouseClicked(MouseEvent e)
    {
    // auszuführender Code
    }
    }

Danach brauchen wir die Ereignisbehandlungsmethode nur noch mit dem Applet zu verbinden. Hierfür verfügt das Applet über eine geerbte Methode namens addMouseListener(). Dieser übergeben wir ein Objekt unserer Mauslauscher-Klasse.

MeinMausLauscher obj = new MeinMausLauscher();
addMouseListener(obj);

Falls man das MeinMausLauscher-Objekt, das mit new MeinMausLauscher() erzeugt wird, nur dazu braucht, um es an die Methode addMouseListener() zu übergeben, kann man den obigen Code vereinfachen, indem man das Objekt direkt im Methodenaufruf erzeugt. Es wird dann automatisch an den Parameter der Methode übergeben.

addMouseListener(new MeinMausLauscher());

Den vollständigen Code für unser Applet sehen Sie in Listing 15.8

Listing 15.8: Mausklick.java

// Mausklicks
import java.awt.*;
import java.applet.*;
import java.awt.event.*;

public class Mausklick extends Applet
{
String meldung;
int x, y;

class MeinMausLauscher extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{
meldung = "Mausklick bei (" + String.valueOf(e.getX())
+ "," + String.valueOf(e.getY()) + ")";
x = e.getX();
y = e.getY();

repaint();
}
}

public void init()
{
addMouseListener(new MeinMausLauscher());
setBackground(Color.red); // roter Applet-Hintergrund
}


public void paint(Graphics gc)
{
gc.drawString(meldung, x, y);
}
}

Die mouseClicked-Methode beginnt damit, dass sie die auszugebende Meldung aufbaut. Diese besteht aus einem Text (»Mausklick bei«) und den Koordinaten des Mausklicks. Die Koordinaten des Mausklicks können wir mit Hilfe der Methoden getX() und getY() vom dem MouseEvent-Parameter der mouseClicked-Methode abfragen. Leider sind die zurückgelieferten Koordinaten echte Ganzzahlen. Wir müssen die Koordinaten daher zuerst in Strings umwandeln (mit Hilfe der Methode String.valueOf()). Den vollständig aufgebauten Meldungsstring weisen wir der Instanzvariablen meldung zu.

Anschließend speichern wir die Koordinaten des Mausklicks in den Instanzvariablen x und y und fordern das Applet auf, sich selbst neu zu zeichnen.

Rufen Sie die paint()-Methode nie direkt auf, wenn Sie möchten, dass das Applet aktualisiert wird. Rufen Sie stattdessen die Methode repaint() auf.

Abbildung 15.8:  Mausklicks in Applet abfangen

15.6 Wie geht es weiter?

Heute haben wir Sie ein wenig in die Programmierung mit Java und in die Erstellung von Applets für Webseiten eingeführt. Etliche wichtige Techniken konnten wir dabei nur kurz erläutern, etliche weitere interessante Aspekte und Möglichkeiten konnten wir nicht einmal anreißen:

Immerhin, Sie wissen jetzt, wie Applets funktionieren, und sollten in der Lage sein, eigene einfache Applets zu erstellen und in Ihre Webseiten einzubinden. Außerdem haben Sie Grundkenntnisse erworben, die Ihnen morgen, wenn wir eine Laufschrift als Beispiel für eine Applet-Animationen erstellen, zugute kommen werden.

Wenn Sie sich gründlicher und tiefer in die Programmierung mit Java einarbeiten wollen, besorgen Sie sich entsprechende Fachliteratur (siehe Anhang E) oder laden Sie sich das Java-Tutorial von der Sun-Website java.sun.com herunter.

15.7 Zusammenfassung

Heute haben Sie gelernt, wie man mit Java Applets für Webseiten erstellt.

Sie haben die Website http://java.sun.com besucht, von der man sich stets die aktuelle Java- Entwicklungsumgebung und aktuelle Dokumentationen und Tutorien herunterladen kann.

Wir haben Sie in die Arbeit mit den Java-Entwicklungswerkzeugen vertraut gemacht, und vielleicht haben Sie dabei sogar ein bisschen mehr über die Konsole Ihres Betriebssystems erfahren.

Danach haben wir unser erstes Applet erstellt, kompiliert und mit Hilfe des <applet>-Tags in eine Testwebseite eingebunden:

<applet code="HalloWWW.class" 
widht="100" height="80">
</applet>

Die Programmiersprache Java ist rein objektorientiert und daher nicht einfach zu erlernen. So mussten Sie sich heute mit einer Vielzahl von neuen Konzepten, Techniken und Syntaxformen auseinandersetzen. Vielleicht hat Sie die Sprache Java dennoch fasziniert und Sie haben - obwohl die Applets, die wir heute erstellt haben, aus didaktischen Gründen möglichst einfach und deswegen weniger praxisrelevant waren - eine Ahnung davon bekommen, wie leistungsfähig und mächtig diese Sprache ist. Vielleicht fühlen Sie sich von Java aber auch ein wenig überfordert. Dann sollten Sie nicht verzagen, sondern sich darüber freuen, dass man viele Dinge auch mit JavaScript realisieren kann.

15.8 Fragen und Antworten

Frage:
Auf der Buch-CD ist eine Version der Java-Entwicklungsumgebung enthalten. Sollte ich trotzdem die aktuelle Version von der Java-Website herunterladen?

Antwort:
Nein. Um die Beispiele aus diesem Buch nachzuvollziehen und sich in Java einzuarbeiten, ist die auf der Buch-CD befindliche Version absolut ausreichend. Wenn Sie allerdings professionell in die Java-Programmierung einsteigen wollen, sollten Sie sich von Zeit zu Zeit auf der Java-Sun-Website umsehen, ob nicht eine aktuellere Version der Java-Entwicklungsumgebung angeboten wird und sich diese gegebenenfalls herunterladen.

Frage:
Was ist Swing?

Antwort:
Java verfügt über zwei Sammlungen von Steuerelementen: AWT-Steuerelemente und Swing-Steuerelemente. Die AWT-Steuerelemente sind so implementiert, dass Sie auf die in den Betriebssystemen der Anwender integrierten Steuerelemente zurückgreifen, die Swing-Steuerelemente tun dies nicht. Während sich das Aussehen der AWT-Steuerelemente daher immer an das Betriebssystem des Anwenders anpasst, hat man bei Verwendung der Swing-Steuerelemente die Wahl, ob man das Erscheinungsbild anpassen lassen oder fest vorgeben möchte.

15.9 Workshop

Der Workshop enthält Quizfragen, die Ihnen helfen sollen, Ihr Wissen zu festigen, und Übungen, die Sie anregen sollen, das eben Gelernte umzusetzen und eigene Erfahrungen zu sammeln. Versuchen Sie, das Quiz und die Übungen zu beantworten und zu verstehen, bevor Sie zur Lektion des nächsten Tages übergehen.

Quiz

  1. Kann man mit Java nur Applets erstellen?
  2. Wieso können Applets auf verschiedenen Plattformen ausgeführt werden?
  3. Welche drei Attribute muss man angeben, wenn man ein Applet mit Hilfe des <applet>-Tags in eine Webseite einbettet?
  4. Von welcher Basisklasse muss man die Hauptklasse eines Applets ableiten?
  5. Wie gibt man in einem Applet Text aus?
  6. Wie setzt man die Hintergrundfarbe eines Applets?

Übungen

  1. Erweitern Sie das Fleckenapplet aus Abschnitt 15.4.3 um eine Ereignisbehandlung für Mausklicks im Applet. Bei jedem Mausklick soll die Farbe der Flecken geändert werden.



vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbackKapitelanfangnächstes Kapitel


123

© Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH