Java-Applets mit NetBeans/BlueJ1

Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
Einführung in die Informatik
- Teil 1 Java-Applets mit NetBeans/BlueJ1
Inhalt:
1.
2.
3.
4.
5.
6.
7.
Ein erstes Applet
HTML-Seiten und Applets
Das Übersetzen von Programmen
Das Hilfesystem
Einige Grafikbefehle
Ein erstes Beispiel
Aufgaben
Literaturhinweise:
• Küchlin/Weber: Einführung in die Informatik, Objektorientiert mit Java,
Springer 1998
• Krüger, Guido: Handbuch der Java-Programmierung,
http://www.javabuch.de oder Addison Wesley 2002
• Tutorials zu NetBeans und BlueJ
1
Copyright SUN (www.sun.com) / BlueJ (www.bluej.org)
S. 1
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
1.
S. 2
Ein erstes Applet
Sollten Sie nur über einen älteren Rechner verfügen, dann lassen Sie besser die Finger von
grafischen Entwicklungsumgebungen! Ansonsten: NetBeans ist ein mächtiges Werkzeug, das
über entsprechend viele Einstellungsmöglichkeiten verfügt, in denen man sich ganz schön
verheddern kann. Zum Glück gibt es eine umfangreiche, frei zugängliche Dokumentation. Bei
der Installation und den ersten Schritten hält man sich am besten an diese. In Tutorials ist das
Ganze gut beschrieben.
Obwohl Applets (also Programme, die in einem Browser ablaufen können) etwas aus der
Mode gekommen sind, wollen wir sie als Erstes benutzen. Kinder wollen zeigen, was sie Tolles gebaut haben, und das können sie sehr leicht in einem Browser. Die Unterschiede zur
Entwicklung von Applications (Anwendungen, also Programmen, die unter einem Betriebssystem direkt gestartet werden) ist bei Verwendung einer IDE (einer integrierten Entwicklungsumgebung) wie NetBeans minimal, so dass es eher egal ist, womit wir beginnen.2
NetBeans arbeitet mit Wizards, also Hilfsprogrammen, die einen ganz gut durch die einzelnen Stufen verschiedener Prozesse leiten. Diese arbeiten mit den Voreinstellungen, die sie
vorfinden. Eine davon ist die, Daten im Homeverzeichnis des Benutzers abzulegen. Da ich
nichts davon halte, mit Anwendungsprogrammen im Stammverzeichnis von Windows zu arbeiten, wollen wir das als erstes abstellen. Dazu legen wir ein neues Verzeichnis für NetBeans-Projekte an, z. B. F:\NetBeans-Projekte.
Nach dem Start von NetBeans erhalten wir ein recht leeres Fenster mit dem üblichen Menü3
sowie einem Willkommens-Bildschirm mit den neuesten Nachrichten über NetBeans – wenn
wir das nicht abgestellt haben (CheckBox unten-rechts).
CheckBox zum Abschalten
der neuesten Nachrichten.
2
Sie merken schon: wir beginnen gleich mit Computer-Kauderwelsch. Da diese Begriffe aber im Netz und der
Literatur ständig benutzt werden, wollen wir sie auch dann benutzen, wenn sie nicht gerade zu gutem Deutsch
führen. Wir müssen die Fachliteratur ja lesen können.
3
Derzeit gibt es die Kombination NetBeans/BlueJ nur in der englischen Version.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 3
Jetzt erzeugen wir ein neues Projekt (File Æ New Project). Ein Projekt ist im Wesentlichen
ein Unterverzeichnis, in dem sich noch ein paar Dateien befinden, die NetBeans Auskunft
über das Projekt geben, z. B. ob und wenn welches Programm ggf. als Erstes zu starten ist.4
Wir erhalten einen neuen Bildschirm, in dem wir auswählen können, welche Art von Projekt
erzeugt werden soll.
Wir wählen die JavaAnwendung aus dem
Ordner „General“ und
klicken den NextButton an.
Dort vergeben wir
einen aussagekräftigen
Namen für das Projekt
(„ProjektMeinErstesApplet“) und – wichtig! – wählen unser
neu angelegtes Projektverzeichnis
als
„Project-Location“
aus. In Zukunft wird
dieses dann immer
automatisch eingetragen, bis wir ein neues
angeben. Die Häkchen
in den beiden CheckBoxes darunter entfernen wir durch Anklicken – das macht das weitere Vorgehen einfacher!
4
Später, wenn Sie Ihre Ergebnisse abgeben, packen Sie einfach so ein Projektverzeichnis in eine ZIP-Datei und
schickes es uns per Mail zu.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 4
Wir haben damit ein leeres Projekt – als einen Rahmen, den es jetzt mit Inhalt zu füllen gilt.
Da wir ein Applet erzeugen wollen, erzeugen wir eine neue Datei (File Æ New File…) und
wählen im erscheinenden Fenster aus den Java GUI Forms die AWT-Forms und von diesen
die Applet Form aus.
Die wählen
wir!
Mit Next > kommen wir zum nächsten Fenster, in dem wir nur den Namen des Applets angeben: MeinErstesApplet (na ja).
Finish beendet diesen Vorgang.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 5
Der NetBeans-Bildschirm ist jetzt schon wesentlich voller! Im Designer-Modus, in dem wir
weitere grafische Elemente einfach im Applet platzieren können, sehen wir:
Die Dateien des
Projektverzeichnisses
Elemente des aktivierten Objekts
Die (hier aufgeklappte)
Palette, aus der wir
Elemente wie Buttons
etc. in das Applet ziehen können.
Das eigentliche
Applet
Fenster für Meldungen des
Systems, Ausgaben, …
Klicken wir aus den Source-Reiter (neben „Design“), dann erscheint der bisher automatisch
generierte Quellcode des Applets. Wir sehen Java-Code: Das Grundgerüst eines leeren
Applets.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 6
In diesem sind einige Kommentare (die mit /* … */ oder /** … **/ „geklammert“ werden)
sowie die Methode init „eingeklappt“. Durch Klicken auf die Plus-Zeichen können wir sie
„aufklappen“.
Init dient dazu, eventuell mithilfe der Palette erzeugt Elemente im Applet zu initialisieren. Da
wir solche – außer einem BorderLayout – nicht haben, ist der Code weitgehend leer.
Kommentare, die Sie später auch selbst zur Dokumentation Ihres Programms einfügen müssen, sind so eine Sache. Einerseits erklären Sie den Programmtext und können auch zur Automatischen Dokumentation benutzt werden (in der zweiten Form), andererseits verlängern
Sie natürlich auch das Programm. Da unser Applet kaum etwas bewirken wird, wollen wir sie
vorerst einfach löschen. Damit erhalten wir eine kleinere Version des Applets (die auftretenden Begriffe werden später erklärt):
public class MeinErstesApplet extends java.applet.Applet
{
public void init()
{
try
{
java.awt.EventQueue.invokeAndWait(new Runnable()
{
public void run()
{
initComponents();
}
});
}
catch (Exception ex)
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
{
}
}
S. 7
ex.printStackTrace();
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">
private void initComponents()
{
setLayout(new java.awt.BorderLayout());
}// </editor-fold>
// Variables declaration - do not modify
// End of variables declaration
}
Um etwas Sinnvolles zu erreichen, wollen wir einen Button in das Applet einfügen, mit dessen Hilfe wir die Farbe ändern können. Wir schalten dazu in den Design-Modus zurück (View
Æ Editors Æ Design) und ändern im Inspektor das BorderLayout des Applets (alles wird
„an den Rändern“ platziert) zu Null-Layout (wir können Elemente frei verschieben). Zur Änderung benutzen wir die rechte Maustaste!
Danach ziehen wir einen Button aus der AWT-Palette in das Applet. Dieser erhält standardmäßig die Aufschrift button1. In den Properties (Eigenschaften) des Buttons können wir die
Aufschrift (das Label) und andere Eigenschaften (Größe, Name, ….) ändern. Wir ändern das
Label in „Werde rot!“ und den Namen in bFarbe („b“ von „button“).
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 8
Zuletzt fügen wir dem Button eine Methode bFarbeActionPerformed hinzu (den Namen
vergeben wir notfalls „perHand“), klicken auf Code und ergänzen den (ersten!) selbst geschriebenen Java-Code:
• Vor dem Applet die Zeile
import java.awt.*; //alle Elemente der AWT-Bibliothek importieren
• Im Eventhandler bFarbeActionPerformed die Zeile
this.setBackground(Color.RED);
//Hintergrundfarbe des Applets („this“) ändern
Jetzt starten wir das Applet mit Run Æ Run File Æ Run MeinErstesApplet.java oder kürzer mit Umschalt-F6 und erhalten das folgende Bild im Applet-Viewer, …
… das sich
nach
Anklicken des Buttons wie gewünscht
ändert.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
2.
S. 9
HTML-Seiten und Applets
Beim Übersetzen hat NetBeans aus der Quelltextdatei des Applets (MeinErstesApplet.java)
eine vom Java-Interpreter ausführbare Datei (MeinErstesApplet.class) erzeugt. Diese wird
vom Appletviewer verarbeitet. Wollen wir das Applet in einer HTML-Seite ansehen, dann
können wir die automatisch von NetBeans im build-Ordner erzeugte Datei nehmen. Diese
öffnen wir (File Æ Open File Æ …) und sehen uns den Text einmal an (ohne Kommentare):
<HTML>
<HEAD>
<TITLE>Applet HTML Page</TITLE>
</HEAD>
<BODY>
<H3><HR WIDTH="100%">Applet HTML Page<HR WIDTH="100%"></H3>
<P>
<APPLET codebase="classes" code="MeinErstesApplet.class"
width=350 height=200></APPLET>
</P>
<HR WIDTH="100%"><FONT SIZE=-1><I>Generated by NetBeans IDE</I></FONT>
</BODY>
</HTML>
Für uns ist nur der fett gesetzte Abschnitt wichtig. In diesem wird angegeben, dass die classDatei des Applets im Unterverzeichnis classes zu finden ist (codebase=“classes“) und die
Applet-Datei den Namen „MeinErstesApplet.class“ hat (code=“MeinErstesApplet.class“).
Weiterhin werden die Appletmaße angegeben (350 x 200 Pixel). Wollen wir eine andere Größe vorgeben, dann können wir diese Werte einfach ändern.
Wenn wir die aktuellen Java-Versionen
benutzen, dann kann es vorkommen, dass
unser Browser die neuen Möglichkeiten
noch gar nicht kennt. In diesem Fall kann
das Applet nicht angezeigt werden. In
meiner aktuellen Version von NetBeans
klappt es ganz gut mit Mozilla, mit dem
Internet-Explorer derzeit eher weniger.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 10
Wie arbeitet eigentlich ein Applet? In welcher Reihenfolge werden die Befehle überhaupt
ausgeführt?
Zur Beantwortung dieser Frage müssen wir das Zusammenspiel von Browser (bzw. AppletViewer) und Applet etwas genauer ansehen.
Unsere HTML-Datei enthält ja Anweisungen, die den Browser veranlassen, entsprechende
Objekte wie Textzeilen oder ein Applet zu erzeugen und anzuzeigen. Der Browser enthält
dann diese Objekte, n Textzeilen und ein Applet der Klasse MeinErstesApplet. Diese wiederum erbt alle Eigenschaften der Standard-Appletklasse namens Applet. In einem UMLKlassendiagramm stellt man das entsprechend dar:
Man erzeugt ein neues Applet (z. B. mit dem Namen Applet1), indem man eine neue Klasse
aus der Mutterklasse Applet ableitet: public class Applet1 extends Applet {...}.
Damit die Mutterklasse gefunden wird, muss man vorher die Bibliothek (Package) angeben,
in sie sich befindet: import java.applet.*; Bei Bedarf folgen weitere Packages, z.B. mit
import java.awt.*; (Informationen zur „richtigen“ objektorientierten Programmierg OOP
folgen später!)
Programmiert wird, indem die (leeren) Standardmethoden der Applet-Klasse durch eigene
Methoden überschrieben (ersetzt) werden. Standardmethoden sind z.B.
•
init()
wird anfangs einmal ausgeführt.
•
start()
wird bei jedem Neustart ausgeführt ausgeführt.
•
stop()
wird am Ende ausgeführt.
Weil wir meist mit Grafik arbeiten wollen, müssen wir noch die Zeichenmethode überschreiben, die einen Grafikkontext g bereitstellt, den wir uns als ein Zeichenblatt vorstellen können,
das einen Stift, einen Pinsel, ein Textwerkzeug usw. enthält.
•
paint(Graphics g)
Die Methoden werden beim Start des Applets vom Browser automatisch aufgerufen.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 11
Wir erhalten damit das Gerüst eines Applets:
import java.awt.*;
import java.applet.*;
public class Applet1 extends Applet
{
public void init()
{
// z.B. Initialisierungen
}
public void start()
{
// z.B. Hintergrund neu zeichnen
}
public void paint(Graphics g)
{
// Grafikbefehle
}
}
public void stop()
{
// braucht man nur selten
}
Kommentare kann man in Java mit einem Doppelstrich (//) einleiten. Der restliche Text der
Zeile wird dann vom Java-Übersetzer überlesen.
Diese Methoden werden vom Browser in einer festgelegten Reihenfolge aufgerufen, die wir
durch ein UML-Sequenzdia-gramm gut darstellen können:
Wir sehen, dass zuerst der
Konstruktor des Applets aufgerufen wird. Überschreiben
wir den Applet-Standardkonstruktor, so können wir schon
dort erste Einstellungen vornehmen.
Üblicher ist es, in der InitMethode z. B. die Komponenten (Buttons, …) zu initialisieren. NetBeans tut dieses, indem es dort eine Methode
initComponents(); aufruft,
die die Einstellungen vornimmt, die wir im Designer
„perHand“ gesetzt haben.
Damit wir dem System hier
nicht
dazwischenpfuschen,
versteckt es diese Methode
erstmal. Klappen wir sie auf,
dann erscheinen die eingestellten Werte:
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 12
private void initComponents()
Button erzeugen
{
bFarbe = new java.awt.Button();
und Werte setzen
setLayout(null);
bFarbe.setLabel("Werde rot!");
bFarbe.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(java.awt.event.ActionEvent evt)
{
bFarbeActionPerformed(evt);
Ereignisbehandlungsme}
thode hinzufügen, die
});
add(bFarbe);
bFarbeActionPerformed
bFarbe.setBounds(80, 110, 72, 24);
aufruft
}
Größe einstellen und zum Applet hinzufügen
3. Das Übersetzen von Programmen
Man schreibt ein Java-Applet im Editor. Schon bei der Eingabe werden sehr viele Fehler von
NetBeans erkannt und angezeigt (durch „Unterpunkten“ und ein rotes „x“ vor der Zeile).
Manchmal muss man ein bisschen warten, damit sich das System den Text „ansehen“ kann.
Bringen wir den Mauszeiger über das „x“, dann wird der Fehler im Klartext angezeigt.
Fehlermeldung
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 13
Typische Fehler sind
•
falsche Groß-/Kleinschreibung
•
falsche Klammerstruktur („Klammer fehlt“)
•
Fehler in den Parameterlisten („ein Wert zu viel“)
•
Typfehler („Zahl statt Zeichen“)
Übersetzt man das Programm, dann werden gefundene Fehler im unteren Fenster Test Results angezeigt. Klickt man auf die Fehleranzeige, dann springt der Cursor in die entsprechende Zeile. Während der Eingabe blendet NetBeans mögliche Optionen ein. Schreibt man
also z. B. „this.“ (d.h. this und „Punkt“) und wartet einen Augenblick, dann erscheint ein
Fenster mit den möglichen Methoden von this (dem Applet), den „Befehlen“.
Wählt man eine Methode aus und tippt die öffnende Klammer, dann erscheint eine Liste mit
den notwendigen Parametern.
Durch Verbessern der Fehler und erneutes Übersetzen erhält man schrittweise ein Programm,
das frei von Syntaxfehlern ist und übersetzt werden kann. Der Java-Compiler (Übersetzer)
erzeugt dann aus der Quellcode-Datei nnn.java eine Code-Datei nnn.class im angegebenen Package (also einem Unterverzeichnis), die dann auf der HTML-Seite angegeben wird.
Die Class-Datei enthält Code für die virtuelle Maschine von Java (die Java-VM, einen „Modellcomputer“), die in den verschiedenen Browsern enthalten ist. Da alle diese virtuellen Maschinen den gleichen Code „verstehen“, können Java-Programme auf allen diesen Rechnern
unabhängig vom Betriebssystem ablaufen. (Leider arbeiten die verschiedenen Java-VMs nicht
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
S. 14
Eckart Modrow
völlig identisch, so dass die Ergebnisse des gleichen Applets durchaus unterschiedlich ausfallen können.)
import java.awt.*
import …
class test extends ..
{
int I=0;
…..
}
Übersetzung durch
NetBeans
Quellcode
(in nnn.java)
LDA 0
STA (234)
….
Javacode
(in nnn.class)
Interpretation
durch die virtuelle
Java-Maschine
00100111101
11010010100
01010101101
……
ausführbarer Code
(rechnerspezifisch)
Logische Fehler befinden sich meist auch in dem Programm. Diese können beim Debuggen (Fehlersuche) gefunden werden, wenn ein Programm schrittweise ausgeführt wird und
die aktuellen Werte der Variablen im Überwachungsfenster verfolgt werden.
Zuerst setzen wir im Quelltext einen (oder mehrere) Breakpoints, indem wir links neben die
Zeile klicken. Sollen diese Befehle ausgeführt werden, dann stoppt das System, so dass wir
den momentanen Zustand ansehen können.
Wir wählen dazu aus dem Menü Run Æ Run File Æ Debug <Appletname>
und warten eine Weile, bis der Debugger gestartet wurde. Nachdem das System gestoppt hat,
können wir mit Run Æ New Watch z. B. die Werte einzelner Variabler im Watch-Fenster
verfolgen und zusehen, wie sich der Debugger durch die Javamethoden des Laufzeitsystems
wühlt. Durch Drücken von F7 bzw. F8 können einzelne Befehle bzw. ganze Methoden ausgeführt werden.
ein Breakpoint
überwachte
Ausdrücke anzeigen
überwachte Ausdrücke
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
4.
S. 15
Das Hilfesystem
Die genaue Arbeitsweise und die Bedeutung z.B. der Parameter erhält man durch das Hilfesystem von NetBeans. Man setzt dazu den Cursor im Editor auf einen Befehl und drückt die
rechte Maustaste. Aus dem Kontextmenü wählt man den Punkt Show Javadoc.
Geschieht das z. B. bei drawLine, so erhält man zuerst eine Übersicht über die Klasse Graphics, aus der man die Details für drawLine auswählen kann.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
5.
(einige) Grafikbefehle
clearRect(int,int,int,int)
draw3DRect(int,int,int,int,boolean)
drawArc(int,int,int,int,int,int)
drawLine(int,int,int,int)
drawOval(int,int,int,int)
drawPolygon(int[],int[],int)
drawRect(int,int,int,int)
drawRoundRect(int,int,int,int,int,int)
drawString(string,int,int)
fill3DRect(int,int,int,int,boolean)
fillArc(int,int,int,int,int,int)
fillOval(int,int,int,int)
fillPolygon(int[],int[],int)
fillRect(int,int,int,int)
fillRoundRect(int,int,int,int,int,int)
setColor(Color)
setXORMode(Color)
setPaintMode(Color)
6.
S. 16
löscht ein Rechteck
zeichnet ein Rechteck
zeichnet einen Kreisbogen
zeichnet eine Linie
zeichnet eine Ellipse
zeichnet ein Polygon
zeichnet ein Rechteck
zeichnet ein abgerundetes Rechteck
zeichnet einen Text
zeichnet ein gefülltes Rechteck
zeichnet einen gefüllten Kreisbogen
zeichnet eine gefüllte Ellipse
zeichnet ein gefülltes Polygon
zeichnet ein gefülltes Rechteck
zeichnet ein gefülltes abger. Rechteck
setzt die Zeichenfarbe
setzt den invertierenden Zeichenmodus
setzt den „normalen“ Zeichenmodus
Ein erstes Beispiel
Wir wollen Zufallsrechtecke mit
Zufallsfarben auf den Bildschirm
„zaubern“. Dazu bestimmen wir
jeweils die obere linke Ecke eines
Rechtecks, seine Breite und seine
Höhe durch (geeignete) Zufallszahlen. Die erhalten wir durch eine nette Bitte an das Math-Objekt, uns
solche zu liefern: Math.random();
Die erhaltenen Zahlen liegen zwischen Null und Eins. Wir „strecken“
deshalb zuerst den Zahlenbereich
mit einem Faktor m und erhalten
Zufallszahlen zwischen Null und m,
danach bitten wir erneut das MathObjekt, das Ergebnis zu runden:
Math.round(Math.random()*m);
Da das Ergebnis nicht unbedingt eine ganze Zahl vom Typ int sein muss, erzwingen wir eine
entsprechende Typwandlung (type-casting), indem wir die Anweisung (int) voranstellen.
(int)Math.round(Math.random()*m);
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
S. 17
Eckart Modrow
Wenn wir mehrmals Zufallszahlen dieser Art erzeigen wollen, dann stellen wir am besten eine
entsprechende Funktion bereit, die solche Zahlen berechnen. Der Rückgabewert der Funktion
ist int. Mit return definieren wir diesen Wert.
public int zz(int m)
{
return (int)Math.round(Math.random()*m);
}
Variable müssen in Java zusammen mit ihrem Wert vereinbart werden, bevor man sie benutzen kann. Für unsere Rechtecke benötigen wir vier ganze Zahlen x, y, b und h, die die obere
linke Ecke sowie Breite und Höhe des Rechtecks beschreiben. Weil wir noch eine Zufallsfarbe bestimmen wollen, vereinbaren wir diese gleich mit.
int x,y,b,h;
Color c;
Allgemein muss eine Variablenvereinbarung der folgenden Syntax gehorchen:
Variablentyp
;
Variablenname
=
Wert
,
Als Typen stehen Zahlen (int, double, long, ...), Wahrheitswerte (boolean), Zeichenketten
(String), Farben (Color) und weitere Klassen zur Verfügung. Die Vorgabewerte müssen natürlich dem Datentyp der Variablen entsprechen.
In unserem Programm wollen wir jeweils 10 Zufallsrechtecke zeichnen. Da hierfür immer die
gleichen Vorgänge (Zufallszahlen und Farben bestimmen, Rechtecke zeichnen, ...) erforderlich sind, packen wir diese in eine Zählschleife, die dafür sorgt, dass der Schleifenkörper so
oft ausgeführt wird, wie der Schleifenkopf angibt.
for (int i=0;i<max;i++)
{
...
Die Zählvariable i erhält anfangs den Wert 0.
Die Schleife wird ausgeführt, solange i kleiner
als max ist (Abbruchbedingung). Nach jedem
Durchlauf wird i um 1 erhöht.
}
Allgemein muss eine Zählschleife der folgenden Syntax gehorchen:
for
(
;
;
Initialisierung
Aktualisierung
)
Abbruchbedingung
{
Befehle
}
• Im Initialisierungsteil werden Variable vereinbart und Anfangswerte gesetzt.
• In der Abbruchbedingung wird vereinbart, unter welchen Bedingungen die Schleife weiter ausgeführt werden soll.
• Im Aktualisierungsteil werden die Werte der Variablen verändert.
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
S. 18
Innerhalb der Schleife basteln wir in unserem Programm aus den Farbwerten Rot, Grün und
Blau im RGB-System eine Zufallsfarbe zusammen, mit der wir die Rechteckfläche zeichnen.
Dann wird noch ein etwas breiterer weißer Rand erzeugt.
import java.awt.*;
import java.applet.*;
public class Mondrian extends Applet
{
int max=10; //Anzahl der Rechtecke
eine Variable
public int zz(int m)
{
return (int)Math.round(Math.random()*m);
}
eine selbst geschriebene Funktion, die aus der
Mathematikbibliothek „Math“
die Methoden
„round()“ und
„random()“ benutzt.
public void paint(Graphics g)
{
int x,y,b,h;
Color c;
for (int i=0;i<max;i++)
{
x = zz(50)+10;
Farbe aus Zufallszahlen
y = zz(30)+10;
zusammenbasteln
b = zz(600-x-20)+10;
h = zz(400-y-20)+10;
c = new Color(zz(255),zz(255),zz(255));
g.setColor(c);
g.fillRect(x,y,b,h);
g.setColor(Color.white);
Rechteck mit Rand
g.drawRect(x,y,b,h);
zeichnen
g.drawRect(x+1,y+1,b-2,h-2);
g.drawRect(x+2,y+2,b-4,h-4);
}
}
}
Virtuelle Lehrerweiterbildung Informatik in Niedersachsen
Java-Applets mit NetBeans/BlueJ
Eckart Modrow
7.
Aufgaben
1. a: Erzeugen Sie Zufallsrechtecke auf dem
Bildschirm. Sie können das Programm
mehrfach ausführen, indem Sie „Aktualisieren“ im Browser anklicken.
b: Sorgen Sie dafür, dass die Rechtecke farbig werde.
c: Wählen Sie die Zufallsfarben „geschmackvoll“, also nicht beliebig, sondern
gezielt. Sie könnten z.B. Farben überwiegend aus dem Bereich grün-blau wählen,
mit gelegentlichen gelben „Ausrutschern“.
2. a: Erzeugen Sie gefüllte Zufallsrechtecke auf
dem Bildschirm. Informieren Sie sich dazu über die Methode SetXORMode() des
Graphics-Objekts.
b: Sorgen Sie dafür, dass die Rechtecke farbig werden.
c: Wählen Sie wiederum „geschmackvolle“
Zufallsfarben (s. Aufgabe 1.c).
d: Entsteht in Ihrem Programm eine „Gewichtung“ der Zufallsrechtecke wie in den
nebenstehenden Beispielen? („Kleinere
Strukturen unten-rechts.“) Wie kommt
das? Kann man den Effekt gezielt erzeugen? Kann man andere Gewichtungen erzielen?
3. a: Informieren Sie sich im Hilfesystem über
die Methode fillArc() des GraphicsObjekts. Erzeugen Sie eine Grafik ähnlich
der nebenstehenden mit Hilfe dieser Methode.
b: Wechseln Sie bei den Figuren (zufallsgesteuert?) zwischen Rechtecken, Ellipsen,
Polygonen, ...
c: Versuchen Sie es einmal mit „Zufallstexten“, also Texten, die zufällig über den
Bildschirm verteilt werden. Informieren
Sie sich im Hilfesystem über die Methode
drawString() des Graphics-Objekts.
S. 19