... zu folgenden Themen:
Wir erwarten, dass Sie die Klasse Fractal studieren und danach die beiden Klassen Mandelbrot und Julia implementieren. Wenn Sie beide Klassen programmiert haben, dann gehen Sie zum nächsten Posten Werkzeuge. Dort lernen Sie den Compiler und Interpreter kennen und können Ihre Klassen ausgiebig testen.
Zu jeder öffentlichen Klasse muss eine gleichnamige Datei erstellt werden. Unsere Klasse Fractal zum Beispiel, ist in der Datei Fractal.java implementiert. Ihre Mandelbrot- und Juliaklasse müssen Sie deshalb in den Dateien Mandelbrot.java bzw. Julia.java implementieren, ansonsten können Sie im nächsten Posten Ihre Programme nicht übersetzen.
Jede Javadatei wird nach dem gleichen Muster erstellt. Der folgende Programmausschnitt stammt aus einer Klasse, welche wir in einem späteren Werkstattposten nochmals anschauen werden. (Die Zeilennummer gehören nicht zum Programm):
1:import java.lang.*;
2:
3:public class BinTree {
4: Element root;
5: ...
6: BinTree() {
7: root = null;
8: }
9:
10: public void insert(int key) {
11: Element t = this.root;
12: boolean done = false;
13:
14: if (this.root == null) {
15: ...
16: } // Ende der Methode insert
17:
18: private Element parentOfLeftMost(Element t) {
19: ...
20: } // Ende der Methode parentOfLeftMost
21: } // Ende der Klasse BinTree
Als erstes müssen wir die verwendeten Klassen importieren. Da meistens mehrere Klassen im Spiel sind, erlaubt Java mit dem * mehrere Klassen gleichzeitig zu importieren. Im obigen Beispiel werden in Zeile 1 alle java.lang Klassen wie java.lang.Boolean, java.lang.Math, java.lang.Long, java.lang.Float usw. importiert.
In Zeile 3 beginnt die eigentliche Klassendefinition: public class Klassenname. Falls die Klasse von anderen Klassen verwendet wird, müssen wir das Schlüsselwort public voranstellen, sonst ist die Klasse nur innerhalb der Datei sichtbar.
Jetzt folgt die Deklaration der Instanzvariablen, welche wie in der Programmiersprache C deklariert werden (Zeile 4).
Im obigen Beispiel erscheint in der Zeile 6 die erste Methode BinTree(). Diese Methode besitzt den gleichen Namen wie die Klasse und wird Konstruktor genannt und wird beim Erzeugen einer neuen Instanz automatisch von Java aufgerufen. Beispiel: Beim Ausführen der Anweisung tree = new BinTree() wird die Konstruktormethode BinTree aufgerufen und root auf null initialisiert (Zeile 7). Selbstverständlich können Sie die Konstruktormethode auch mit Parameter aufrufen.
In Zeile 10 definieren wir die Methode insert. Das Wort public am Anfang der Zeile deklariert die Methode als öffentlich, d.h. die Methode ist von aussen sichtbar. Nach der Publicdeklaration folgt der Rückgabetyp der Methode, in diesem Falle "nichts". Die Definition einer öffentlichen Methode lautet:
public Rückgabetype Methodenname (Parameter) {Code}
Möchten wir Methoden definieren, welche nur innerhalb der Klasse sichtbar sind, dann deklarieren wir diese private, d.h. wir setzen private vor den Rückgabetyp (Zeile 18).
In Java werden Klassen wie folgt erweitert:
public class Klassenname extends Name_der_Oberklasse
Im Mandelbrotbeispiel: public class Mandelbrot extends Fractal
Als nächstes müssen wir uns überlegen, welche Methoden die Mandelbrot- und Juliaklasse überschreiben müssen. Dazu studieren wir zuerst die Fraktalklasse. Der folgende Programmcode ist ein Ausschnitt aus der abstrakten Klasse Fractal. (Zeilennummer gehören nicht zum Code)
1: public abstract class Fractal {
2: protected Color col[] = initColor();
3: protected FCanvas canvas;
4: protected int cx, cy, cw, ch;
5: protected double fx, fy, fw, fh;
6:
7: protected Color[] initColor () {
8: ....
9: }
10:
11: public abstract void draw();
12:
13: }
In Zeile 2 deklarieren und initialisieren wir die Farbtabelle für das Einfärben unseres Fraktals. FCanvas in Zeile 3 ist das Grafikfenster, in dem das Fraktal gezeichnet wird. Zusätzlich zum Grafikfenster müssen wir noch angeben in welchem Bereich gezeichnet werden darf. Deshalb deklarieren wir in Zeile 4 die Werte cx und cy für die x und y Koordinate des Ursprungs, cw und ch für die Breite und Höhe des Grafikfensters. fx, fy, fw und fh in Zeile 5 beschreiben den komplexen Bereich der Menge, die berechnet werden soll. Die Definition einer Konstruktormethode entfällt, da es sich bei der Klasse Fractal um eine abstrakte Klasse handelt und keine Instanzen von ihr erzeugt werden können. Die Methode initColor gibt die Farbtabelle für das Einfärben des Fraktales zurück und wird bei der Initialisierung der Farbtabelle aufgerufen (Zeile 2). In Zeile 11 definieren wir die abstrakte Methode draw. Diese muss von den Erweiterungen Mandelbrot und Julia überschrieben werden.
Ihre Aufgabe ist es, aus der abstrakten Klasse Fractal die konkreten Subklassen Mandelbrot und Julia zu implementieren. Wir müssen somit folgende Überlegung anstellen: Welche zusätzlichen Informationen (Zustände) benötigen wir für die Klassen Mandelbrot und Julia? Welche Methoden müssen erweitert werden und welche müssen neu hinzukommen? Letzteres ist einfach zu beantworten: Die abstrakte Methode draw muss sicher überschrieben werden. Sie berechnet die Fraktalmenge und stellt diese auf dem Bildschirm dar. An der Farbtabelle müssen wir nichts ändern, denn. diese ist unabhängig von der Fraktalart. Somit muss diese Methode nicht überschrieben werden. Eine Konstruktormethode müssen wir bestimmt implementieren, da später Instanzen aus den Klassen erzeugt werden. Mehr benötigen wir nicht, es sei denn, Sie wollen noch zusätzliche Eigenschaften einbauen.
Unsere Superklasse definiert alle wichtigen Variablen. Wir müssen somit nur noch neu eingeführte Variablen deklarieren. Es fehlt sicherlich eine Variable für die Schrittweite der Berechnung, und es fehlen Variablen für die Werte a und b, welche beim Aufruf der Konstruktormethode übergeben werden. Je nachdem wie Sie Ihre Methoden implementieren, müssen eventuell noch mehr Variablen definiert werden.
Damit Sie nicht zuviel Zeit mit dem Zeichnen der Menge verlieren geben wir Ihnen den Quellcode des Abschnittes für das Einfärben in der Methode draw an.
// n enthält die Anzahl Iterationen, die notwendig waren um aus der
// Berechnungsschlaufe zu entweichen.
// Faerben gemaess der Geschwindigkeit, mit der sich der
// Punkt vom Startpunkt entfernt.
// i und j sind die Laufvariablen der Doppelschleife.
if (n < 2) { canvas.dot(col[0], cx + j, cy + i); }
else if (n < 4) { canvas.dot(col[1], cx + j, cy + i); }
else if (n < 8) { canvas.dot(col[2], cx + j, cy + i); }
else if (n < 16) { canvas.dot(col[3], cx + j, cy + i); }
else if (n < 32) { canvas.dot(col[4], cx + j, cy + i); }
else if (n < 64) { canvas.dot(col[5], cx + j, cy + i); }
else if (n < 96) { canvas.dot(col[6], cx + j, cy + i); }
else if (n < 144) { canvas.dot(col[7], cx + j, cy + i); }
else if (n < 200) { canvas.dot(col[8], cx + j, cy + i); }
else { canvas.dot(col[9], cx + j, cy + i); }
}
Wenn Sie Java bereits sehr gut kennen, dann versuchen Sie mit diesen Informationen die Klassen Mandelbrot und Julia zu implementieren. Kommen Sie nicht mehr weiter, dann lesen Sie weiter.
Da unsere ersten beiden Javaprogramme für Anfänger schwer zu programmieren sind, können Sie auf unsere Rahmenprogramme zurückgreifen. Es fehlt nur noch die Mandelbrot- bzw. Juliamengenberechnung, alles andere haben wir Ihnen bereits vorgegeben. Falls Sie diese Hilfen anschauen möchten, dann kopieren Sie die Javaprogramme Mandelbrot und Julia in Ihr Arbeitsverzeichnis. Damit Ihre Klassen nicht gelöscht werden, besitzen sie die Dateinamen RahmenMandelbrot.java und RahmenJulia.java. Falls Sie unsere Programme übernehmen möchten, dann müssen Sie das Wort Rahmen aus den Dateinamen entfernen.
OOP Begriffe - Mandelbrot- und Julia-Mengen - Tips und Hinweise - Lösungsmöglichkeit
OOP - Werkzeuge - Referenzen - Fäden - Synchronisation - Applets - Dokumentation
Werkstatt - Bibliographie