Beispiel-Applet - Christian Afonso

JAVA-Grundlagen
Kleinschreibung unterschieden.]
Vorbemerkung: Ich habe dieses Dokument erstellt, um denen zu helfen, die Nach diesen import-Anweisungen folgt nun der Hauptteil:
eigentlich noch nicht richtig wissen, wie sie ein Applet zu erstellen haben (hätte
ich es mir nicht selber beigebracht, wüsste ich es auch nicht). Es vermittelt die
public class AppletName extends Applet {
Grundlagen der Aufbaustruktur eines Applets und die wichtigsten Befehle und
// Hier folgt der gesamte Quelltext
Definitionen. Ich hoffe es hilft weiter! Sonst fragt einfach! 
}
1. Was ist objektorientierte Programmierung?
Bei objektorienterter Programmierung wird nicht (wie z.B. bei TurboPascal) ein
Programmablauf geschrieben, der dann Schritt für Schritt abgearbeitet wird,
sondern es werden mehrere Objekte erstellt, die jeweils bestimmte Sachen tun
und mit anderen Objekten “kommunizieren”. Objekte sind z.B. Buttons oder
Eingabefelder. Objekte benutzen Prozeduren (in JAVA “Methoden” genannt),
um miteinander zu kommunizieren.
Beispiel: Sobald ein Button angeklickt wird, wird der Text von einem
Eingabefeld eingelesen (hier kommunizieren die Objekte miteinander) und eine
Methode aufgerufen, die mit diesem eingegebenen Text irgendetwas anstellt, z.B.
ihn auf dem Bildschirm ausgibt.
2. Grundstruktur eines Applets
(kleine Vorbemerkung: mit JAVA kann man Applets oder Applikationen erstellen,
wobei Applets immer von einem Browser, z.B. Netscape, aufgerufen werden, und
Applikationen selbstlaufende Programme sind. Dafür gibt es natürlich kleine
Unterschiede im Programmtext, weshalb ich vorerst nur Applets erklären werde,
um die Konfusion gering zu halten)
Als erstes müssen in ein Applet einige Standardklassen eingebunden werden, die
z.B. zum Erstellen eines Applets, zur Bildschirmausgabe etc. benötigt werden.
Das sind für unsere Problemstellungen normalerweise:
import java.awt.*;
(für Ein- und Ausgabemethoden und andere nützliche Sachen)
import java.applet.*;
(für das Erstellen und Arbeiten mit Applets)
import java.awt.event.*;
(Für die Event-methoden bzw. ActionListener).
[Wichtiger Hinweis: JAVA ist case-sensitiv, d.h. es wird zwischen Groß- und
Mit dieser Zeile wird eine Klasse mit dem Namen „AppletName“ erstellt, die von der
Standardklasse „Applet“ abgeleitet wird.(Diese Standardklasse ist in java.applet.* enthalten)
Dieses Ableiten ist notwendig, damit unsere Klasse die Standardeigenschaften eines Applets
hat( ein Fenster auf dem Bildschirm z.B.). Wenn wir eine Klasse erstellen, die keine
voreingestellten Eigenschaften haben soll, fällt das „extends Klassenname“ einfach weg. (Das
Erstellen eigener Klassen wird später behandelt)
Das public sagt aus, dass diese Klasse von allen anderen Objekten benutzt werden kann.
[Siehe als Beispiel den Igel: Er ist eine eigene Klasse, die man jedoch von einem Applet aus
benutzen kann] Weitere Optionen zur Sichtbarkeit sind im Moment nicht so wichtig.
Innerhalb dieser Klasse wird jetzt folgendes benötigt:
Zuerst können Variablen deklariert werden.
public class AppletName extends Applet {
int zahl1, zahl2;
// erstellt zwei neue Integerzahlen ohne zugewiesenen Wert
int zahl3 = 15;
// erstellt eine neue Integerzahl, der ein Wert zugewiesen wird
double x, y;
// erstellt zwei Fließkommazahlen ohne Wert;
Button knopf = new Button(„Drück mich!“); // erstellt einen Knopf, auf dem
// „Drück mich“ steht
Button knopf2;
// erstellt einen Knopf, der aber noch initialisiert werden muss
String name1;
// erstellt eine Zeichenkette
String name2 = „Klaus“; // Erstellt eine Zeichenkette, der der Wert „Klaus“
// zugewiesen wird
Hierbei ist zu beachten, dass es sich bei String um eine Klasse handelt, und Klassen werden
GROSS geschrieben ( der Klassenname – nicht der Name der Variable).
Als nächstes folgt die Initialisierung: Alle Variablen, denen vor Programmbeginn ein
fester Wert zugewiesen werden soll, werden hier initialisiert. (Dies empfielt sich, damit man
bei jeder Variable weiß, welchen Wert sie hat – das debuggen könnte sonst ziemlich
umständlich werden.) Außerdem werden hier Objekte erstellt, die am Anfang auf dem
Bildschirm erscheinen sollen, z.B. Buttons;
public void init() {
1
// void bedeutet, dass die Methode keinen Wert zurückgibt;
// die Klammern () enthalten normalerweise die Argumente,
// die der Methode übergeben werden, aber init braucht keine,
// deshalb die leere Klammer.
bzw.
graphikObjektmitWillkürlichemNamen.drawString(„Hallo Welt!“);
gm.drawString(„Hallo Welt!“);
knopf2 = new Button(„Hallo“); // dem erstellten Knopf wird die
// Aufschrift „Hallo“ zugewiesen.
zahl1 = 5;
zahl2 = 10;
x = 5.739;
y = 4.32335;
name1 = „Peter“;
add(knopf);
add(knopf2);
}
// Ende von init
(An diesem Beispiel sieht man gut, weshalb der Name kurz sein sollte, da angegeben werden
muss, auf welchem Graphikobjekt der Text ausgegeben werden soll.)
Wichtige Methoden in paint:
gm.drawString(string, x, y); // Gibt den String an der Position(x,y) aus wobei (0,0) links oben
// in der Ecke ist. [x und y werden in Pixeln angegeben]
gm.drawLine(startx,starty,endx,endy); // dürfte klar sein.
gm.drawRect(startx,starty,endx,endy); // Rechteck, angegeben wird die linke obere und die
Die letzten beiden Zeilen sind dafür da, dass die erstellten Knöpfe auf den
// rechte untere Ecke
Bildschirm gesetzt werden.
HINWEIS: Objekte müssen immer mit new() erzeugt werden, wie z.B.
wobei das „gm“ natürlich durch den Namen eures Graphikobjekts ersetzt wird.
Button knopf = new Button(„Aufschrift“); oder
TextField eingabefeld = new TextField(3); // erzeugt ein Eingabefeld, 3. Methoden
// das Platz für 3 Zeichen hat.
Methoden sind Programmabschnitte mit einem zugewiesenen Namen, die jederzeit aufgerufen
werden können und dann bestimmte Aufgaben ausführen.
Das nächste was unbedingt im Code stehen muss, ist die paint-Methode. sie wird
beim Applet-start gleich nach init aufgerufen und ist für die Bildschirmausgabe Beispielmethode:
zuständig. Wenn der Bildschirm später im Programm neu gezeichnet werden soll,
wird die Methode mit
public void addiere(int zahl1, int zahl2) {
int ergebnis = zahl1 + zahl2;
repaint();
gm.drawString(„Ergebnis:“+ergebnis, 10, 10);
}
aufgerufen. Dieser Methode muss ein Graphik-objekt übergeben werden, auf dem
sie zeichnen und schreiben kann. Da dieses Objekt vom Applet automatisch Was heißt das?
erstellt wird, muss es nicht initialisiert werden!
1. In der ersten Zeile wird eine Methode mit dem Namen „addiere“ deklariert, der zwei
Integer-zahlen übergeben werden[zu beachten ist hier, dass vor jeder Variable angegeben
public void paint(Graphics graphikObjektmitWillkürlichemNamen) {
werden muss, welchen Datentyp sie hat(hier also int)]. Die Methode liefert keinen
// Anweisungen
Rückgabewert, deshalb „void“. Sie kann von überall aufgerufen werden, deshalb „public“.
}
2. Innerhalb der Methode wird eine neue Integerzahl mit dem Namen „ergebnis“ erstellt und
ihr das Ergebnis der Addition der beiden übergebenen Zahlen zugewiesen. Danach wird sie
Wie oben ersichtlich, kann man das Graphikobjekt nennen wie man will, obwohl zusammen mit dem Text „Ergebnis:“ auf dem Bildschirm an der Position (10;10) ausgegeben.
ein kürzerer Name natürlich angebrachter ist, z.B.
Die Methode wird jetzt z.B. aus paint aufgerufen:
public void paint(Graphics gm) {
// Anweisungen
}
Die Anweisungen innerhalb der Methode können z.B. Befehle zum Ausgeben von
Text sein:
public void paint(Graphics gm) {
int x = 16;
int y = 25;
addiere(x, y);
}
2
Hier werden zwei neue Integerzahlen mit den Namen x und y erstellt und ihnen drehe(winkelinGrad); // Dreht nach links; für Rechtsdrehungen ein - davorsetzen
Werte zugewiesen. Danach wird unsere Methode aufgerufen, wobei ihr die beiden
Variablen übergeben werden, die sie addieren soll. Auf dem Bildschirm steht also Der Igel wird mit dem Konstruktor
nach dem Ausführen:
Igel NameDesIgels = new Igel(Graphikobjekt, PosX, PosY, Richtung);
Ergebnis: 41
erstellt. (Normalerweise in paint – Hier soll er ja schließlich zeichnen)
Wenn man das ganze geschickter machen möchte, kann man die Methode so
schreiben, dass sie das Ergebnis dem Aufrufer zurückgibt, so dass dieser weiter
public void paint(Graphics gm) {
damit arbeiten kann:
Igel hans = new Igel(gm, 50, 50, -90);
hans.vor(30);
public int addiere(int zahl1, zahl2) {
hans.drehe(45);
int ergebnis = zahl1 + zahl2;
hans.vor(50);
return ergebnis;
hans.drehe(-45);
}
hans.vor(30);
}
Diese Methode wird jetzt z.B. so aufgerufen:
In diesem Beispiel wird ein Igel mit dem Namen „hans“ an der Position (50;50) erstellt, der
public void paint(Graphics gm) {
nach rechts guckt(die Richtung 0 zeigt nach oben, -90 also nach rechts) und dann folgendes
int x = 16;
auf den Bildschirm malt: (ungefähr)
int y = 25;
__
/
int summe;
summe = addiere(x, y); // Hierbei wird addiere ausgeführt und
__/
// danach der Ergebniswert mit return(siehe oben)
// der Variable „summe“ zugewiesen.
(er geht also erstmal 30 Pixel nach rechts, dreht sich 45° nach links, geht 50 Pixel
summe++; // ist das selbe wie summe = summe + 1
schräg nach oben, dreht sich wieder 45° nach rechts und geht noch 30 Pixel nach
rechts)
gm.drawString(„Ergebnis:“+summe, 10, 10);
}
6. ActionListener
Hier gibt die Methode also einen Integerwert zurück, mit dem danach noch ActionListener sind, wie der Name schon sagt, dafür da, „Bescheid zu sagen“, wenn etwas
gerechnet werden kann. die Bildschirmausgabe sieht dann folgendermaßen aus:
passiert, z.B. ein Knopf gedrückt wurde. Ein ActionListener „lauscht“ immer auf ein Objekt,
d.h. erst muss ein Objekt erstellt werden, bevor ihm ein ActionListener hinzugefügt wird.
Ergebnis: 42
Beispiel-Applet
[Nicht vergessen an dieser Stelle die Standard-klassenpackages einzubinden (import) !!!!! ]
4. Variablentypen
Es gibt folgende wichtigen Variablentypen:
public class Appletname extends Applet { // WICHTIG: Die Datei muss als Appletname.java
int
eine ganze Zahl
// gespeichert werden !!!!
double
Eine Fließkommazahl(Dezimalbruch – bitte einen Punkt benutzen!)
String Name = new String(“ “); // Erstellt einen leeren String
boolean ein Wahrheitswert, kann nur den Wert true oder false haben.
Button knopf = new Button(„Drück mich!“); // Erstellt einen Knopf
String
eine Zeichenkette, eingeschlossen von Anführungszeichen “ Text “
TextField name = new TextField(20); // Erstellt ein Eingabefeld mit Platz für 20 Zeichen
Label text = new Label(„Gib einen Namen ein und drück den Knopf!“); // Erstellt ein
// Label mit der angegebenen Aufschrift
5. Benutzen des Igels
Die Befehle für den Igel sind:
public void init() {
vor(StreckeinPixeln);
add(text); // Platziert das Label auf dem Bildschirm, d.h. der Labeltext wird dort
3
// ausgegeben
add(name); // Platziert das Eingabefeld auf dem Bildschirm
add(knopf); // Platziert den Knopf auf dem Bildschirm
knopf.addActionListener(new ActionListener() { //Fügt dem Knopf
// einen ActionListener hinzu
public void actionPerformed(ActionEvent e) { // Die Methode wird
// aufgerufen, wenn der Knopf gedrückt wurde
Name = name.getText(); // Weist dem String den Inhalt des
// TextFields zu
repaint(); // Malt den Bildschirm neu
} // Ende der ActionPerformed-Methode
} // Ende der Deklaration des ActionListeners
); // Ende der Argument-liste von knopf.addAcctionListener()
} // Ende von init()
public void paint(Graphics gm) {
gm.drawString(„Der eingegebene Name ist“+Name, 50, 50);
}
7. Auch wichtig: Die aufrufende HTML-Seite
Diese kann nach dem Standardmuster gebaut werden:
<html>
<head>
<title>Titel der Seite</title>
</head>
<body>
<applet code = „NamedesApplets.class“ width=BreitedesAppletfensters height=Höhe >
</applet>
</body>
</html>
Das ganze sollte dann noch als NamedesApplets.html gespeichert werden (Es ist praktisch,
dass zu tun, weil man dann immer weiß, welches Applet zu welcher Seite gehört [Ist aber
nicht zwingend])
[Wie die .class-Datei erzeugt wird(kompilieren) werdet ihr wohl schon wissen]
8. P.S.:
Wer es noch nicht bemerkt hat: Alles was in den Quelltextbeispielen kursiv geschrieben ist,
soll durch entsprechende Ausdrücke ersetzt werden (z.B. bei
[Anmerkung: Innerhalb der ActionPerformed-Methode des ActionListeners
public class NamedesApplets extends Applet
stehen die Anweisungen, die ausgeführt werden sollen, wenn eine Aktion
public class IgelBeispiel extends Applet
stattgefunden hat.]
oder so.)
} // Ende des Applets
Bei diesem Applet erscheinen also erstmal drei Elemente auf dem Bildschirm:
eine Aufschrift, ein Eingabefeld und ein Knopf. Dem Knopf wird ein
ActionListener hinzugefügt, der folgendes bewirkt: Jedesmal, wenn der Knopf
gedrückt wurde, wird dem String „Name“ der Inhalt des Eingabefeldes
zugewiesen und der Bildschirm neu gezeichnet, wobei der Text „Der eingegebene
Name ist Name“ ausgegeben wird.
So, das waren alle wichtigen Grundlagen, die mir eingefallen sind. Wenn noch offene
Fragen existieren, dann her damit!

©Christian Afonso
4