3 Hausaufgabe

3
Hausaufgabe
Allgemeines zu allen Aufgabenblöcken:
• Lesen Sie den jeweils einleitenden Aufgabentext und die Aufgabenstellung genau. Damit Sie erläuternden Text von den Aufgabenstellungen
schnell unterscheiden können, sind die Aufgabentexte optisch durch
einen Randbalken hervorgehoben. Pflichtaufgaben sind mit dickem
Randbalken, freiwillig zu bearbeitende Aufgaben mit einem dünnen
Seitenstrich markiert.
• Bearbeiten Sie die Aufgaben zügig. Sollten sich bei der Bearbeitung
Schwierigkeiten ergeben, die Sie nicht selber lösen können, so befragen
Sie Ihren Betreuer (Hiwi) und bitten Sie ihn um Hilfestellung oder
ergänzende Erläuterungen! Sie sollten sich nicht “stundenlang” an einem Problem “festbeißen”!
• Lesen Sie in der angegebenen/empfohlenen Literatur und in unserem
“Einführungstext” nach eigenem Ermessen zu den im folgenden angegebenen Inhalten des Aufgabenblocks.
Inhalt dieser Teilaufgabe, Hinweise zu Informationsquellen:
• Java: Erzeugen, Lebensyzyklus und Zugriff auf Objekte, primitive Datentypen
S. dazu im EIP-Begleittext, Kap. 10 (gesamt)
• Java: objektorientierte Programmierung
S. dazu im EIP-Begleittext, Kap. 14.1 bis 14.6 inkl.
• Java: Klassen, Objekt/Instanz, Zugriff auf Methoden und Attribute
S. dazu im EIP-Begleittext, Kap. 12 bis 12.5 inkl
• Java: Vererbung, Super-/Basisklasse, Subklasse, Erweitern einer Klasse, Ergänzen von Instanzvariablen, Überschreiben von Methoden
S. dazu im EIP-Begleittext, Kap. 14 bis 14.6 inkl.
• Java: Konstruktoren
S. dazu im EIP-Begleittext, Kap. 12.7 und 14.5
• Java: Der Verweisoperator super
S. dazu im EIP-Begleittext, Kap. 14.4
• Java: (in Wdh.) Kontrollstrukturen: if-Verzweigung, for-Schleife
S. dazu im EIP-Begleittext, Kap. 9.5 und 9.7.3,
1
• Java: (neu) Kontrollstrukturen: while- und do while-Schleife
S. dazu im EIP-Begleittext, Kap. 9.7.1 und 9.7.2
• Java: Nutzen der in einem java package vorliegenden Klasse Random
S. dazu auch im EIP-Begleittext, Kap. 15
Anmerkung: Informieren Sie sich zu den soweit erwähnten Inhalten, insbesondere aber zur Vererbung, Erweiterung (extension) von Klassen, zum
Überschreiben von Methoden, dem Verweisoperator super und der Nutzung
von Konstruktoren auch in der Ihnen ergänzend verfügbaren Literatur!
TA 3.1
Legen Sie zur Bearbeitung und Strukturierung Ihrer Lösungen unter Ihrem
directory AB3 6 weitere directories TA1,...,TA6 an und sortieren Sie Ihre
Quellen und Ergebnisse entsprechend ein.
Bisher wurden Klassen als Mittel genutzt, um Daten und Verhalten als eine
Einheit zu konzipieren.
Die objektorientierte Methodik wird aber erst dadurch zu einem mächtigen
Werkzeug, weil sie es erlaubt, mehrere Klassen, die ähnliche Aufgaben haben, zu einer abstrakteren Klasse (der sogen. “Basisklasse”, oder auch “Superklasse”) zusammenzufassen. In der Superklasse sind dann die Daten und
Verhaltensweisen implementiert, die in jeder speziellen Klasse gleich sind.
Somit müssen sie in den speziellen (oder “Sub-“)Klassen nicht wiederholt
niedergeschrieben werden, sondern werden von der Superklasse übernommen (vererbt).
Das folgende Beispiel soll verdeutlichen, wie in Java durch Vererbung eine
(abgeleitete) Subklasse erzeugt wird, d.h. eine neue Klasse definiert wird, die
auf einer bereits bekannten Klasse basiert. Prinzipiell kann dabei die neue
Subklasse eine Erweiterung und/ oder Spezialisierung ihrer Superklasse sein,
d.h. z.B. neue Elemente wie Instanzvariablen oder neue Methoden beinhalten, die dann die Eigenschaften/Fähigkeiten der Superklasse erweitern. Sie
kann aber auch eine in der Superklasse vorhandene Methode “überschreiben”, sie abändern.
Wir wollen uns dieser objektorientierten Techniken bedienen, um aus der
vorhandenen Superklasse Turtle eine neue Subklasse TurnTurtle abzuleiten, die in der Lage ist (über das in Turtle schon konzipierte hinaus) die
2
Summe der Turtle-Drehungen in einem Gesamtdrehwinkel abzuliefern.
Anmerkung: Die Superklasse Turtle ist die von uns im eip-package gegebene Klasse, in
der die turtle-Befehle (methods) auf eine Instanz (also ein Objekt) von turtle angewendet
werden.
In der Erweiterung soll sich der Gesamtdrehwinkel additiv aus den einzelnen
Drehwinkeln rt(angle) und lt(angle) der Turtle ergeben. Ein rechts gedrehter Winkel zählt positiv, ein links gedrehter negativ, sodaß sich der Gesamtdrehwinkel als Summe der insgesamt absolvierten Rechtsdrehung ergibt
(in unserem Screen-Koordinatensystem zeigt nämlich x nach rechts positiv
und y nach unten positiv).
Zur programmtechnischen Realisierung werden in der Subklasse TurnTurtle
die folgenden “Ergänzungen” zur Superklasse Turtle benötigt:
• Die Erweiterung der Superklasse wird definiert, indem im Klassenkopf
der neuen Subklasse das Symbol extends <Superklasse> { ... }
angefügt wird, also hier z.B.:
public class TurnTurtle extends Turtle { ... }.
• Es wird eine Variable (vom Typ double) eingeführt, in der die Summe
aller einzelnen Drehungen der Turtle als Gesamtdrehwinkel totalAngle
gespeichert werden kann.
Anmerkung: Wird in Java ein Objekt einer Klasse angelegt, so wird
für eine einfache Variable (wie totalAngle) automatisch ein Speicherplatz angelegt und dieser (default) auf 0.0 initialisiert.
Soll im Rahmen eines Programms (wie hier) der Gesamtdrehwinkel
evtl. des öfteren neu berechnet werden, so muss es eine Methode in
der Klasse geben, den Winkel bei Aufruf erneut auf 0.0 zu initialisieren (das übernimmt hier die Methode resetAngle() ).
• Zum o.g. Initialisieren des Gesamtdrehwinkels totalAngle auf den
Wert 0.0 wird die Methode resetAngle() angelegt mit:
totalAngle = 0.0;
• Eine weitere Methode getTotalAngle() wird angelegt, um den ermittelten Gesamtdrehwinkel aller Drehungen zurückzugeben durch:
return totalAngle;.
• Die Methoden rt(angle) und lt(angle) der Superklasse Turtle sollen im Rahmen der Vererbung um das Aufsummieren der Winkel erweitert (besser “überschrieben”) werden. Dazu werden die Methoden
mit gleichem Namen und mit gleicher Parameterliste wie in der Superklasse definiert. Das Aufsummieren der Winkel übernehmen bei
rechtsdrehender turtle die Anweisung totalAngle += angle; und bei
3
linksdrehender turtle die Anweisung totalAngle -= angle;
Anmerkung:
Die verkürzende Schreibweise totalAngle += angle; bedeutet in Java:
totalAngle = totalAngle + angle;
entsprechende Bedeutung hat die Variante mit dem Minus-Zeichen.
In den überschriebenen Methoden rt(angle) und lt(angle) werden mit dem Verweisoperator super die Methoden rt(angle) und
lt(angle) der Superklasse Turtle aufgerufen (die ja unverändert weiterhin gebraucht werden).
Anmerkung: Nach den Regeln des Überschreibens wird bei Methoden mit gleichem
Kopf in der Super- und Subklasse stets die Methode der Subklasse verwendet. Durch
die Benutzung des Superklassenverweises super wird diese Regel außer Kraft gesetzt und der Zugriff auf sonst verdeckte Attribute der Superklasse möglich.
• Überschreibt eine Subklasse eine Superklasse, so werden die Konstruktordefinitionen nicht übernommen. Sie müssen explizit aufgerufen werden.
Anmerkung:
Im Sinne einer klaren Programmstrukturierung ist es zweckmäßig, die Anweisungen
zur Bildung des Anfangszustandes (Speicherzuteilung und Initialisierung) in einer
eigenen Methode zusammenzufassen. Java bietet hierfür eine spezielle Methode,
den sogen. Konstruktor. Konstruktoren können - wie Methoden - parametrisiert
sein und somit die Übergabe der Initialisierung via aktueller Parameter gestatten.
Formal muß ein Konstruktor den Namen wie die Klasse besitzen, zu der er gehört.
Er liefert als Ergebnis stets einen Verweis auf das neu erzeugte Objekt an die Aufrufstelle.
Mit super(screen); wird hier aus der Subklasse der Konstruktor der
Superklasse Turtle aufgerufen, so wie (s.o.) allgemein verdeckte Attribute der Superklasse durch die Benutzung des Superklassenverweises
super aus der Subklasse heraus realisiert werden.
Ergänzend wird die Instanzvariable totalAngle initialisiert per Aufruf
von resetAngle();
KlasseTurnTurtlea
a
http://www.wire.tu-bs.de/EIP/ha/ha3/TurnTurtle.java
oder im Pool unter ∼/EIP/ha/ha3/TurnTurtle.java
4
ProgrammExample31a
a
http://www.wire.tu-bs.de/EIP/ha/ha3/Example31.java
oder im Pool unter ∼/EIP/ha/ha3/Example31.java
5
Aufgaben:
1. Verdeutlichen Sie sich die Funktionsweise des Programms Example31,
das den gesamt Drehwinkel der Turtle beim Umlaufen eines Dreiecks
ermittelt.
Anm.:
Mit final wird in Java eine nicht änderbare Konstante definiert (s. Zeile:
public static final int SIDELENGTH = 150;)
In der Methode main wird - wie bisher - ein Objekt ts des turtlescreen angelegt, in
dem sich aber nun eine turtle bewegt, die nicht mehr der Klasse Turtle sondern der
erweiterten Klasse TurnTurtle entstammt. Damit werden deren Methoden in main
nutzbar (resetAngle, getTotalAngle und die erweiterten rt und lt).
Beachten Sie - auch im weiteren Verlauf der Teilaufgaben - , daß die selbst geschriebenen Superklassen für abgeleitete Klassen vom Java BytecodeInterpreter gefunden
werden können, d.h. im CLASSPATH aufgenommen sind.
2. Um die Arbeitsweise des Example31 genauer zu erfahren, lassen Sie die
Turtle jeweils um ein nEck (mit n = 3, 6, 12) (s. Aufgabenblock 2, TA
2.2), entlang einem doodle (s. Aufgabenblock 1, TA 1.6) und entlang
der Koch-Kurve (s. Aufgabenblock 2, TA 2.3) laufen und dabei den
gesamt umlaufenen Drehwinkel ermitteln.
Anm.:
Ziehen Sie dazu die in den Aufgabenblöcken TA 2.2, 1.6 und TA 2.3 erarbeiteten
Programmsequenzen (Methoden) zum Umlaufen entsprechender Figuren hinzu.
3. Um zu verdeutlichen, wie man mittels wiederholter Vererbung die Eigenschaften/Fähigkeiten einer Klasse immer weiter ergänzen und ausbauen kann, dient die folgende Aufgabe (und die freiwillige Zusatzaufgabe TA 3.6), die schrittweise (aufeinander aufbauend) gelöst werden.
Hier soll erst einmal die Fähigkeit der Klasse TurnTurtle (bislang aus
den Methoden rt(angle) und lt(angle) mit erweiterter Berechnung
des Gesamtdrehwinkels ) durch Vererbung so erweitert werden, daß
eine neue Klasse PathTurnTurtle entsteht, die zusätzlich auch die
Gesamtlänge der zurückgelegten Wegstrecke aufsummiert.
Analog dem Vorgehen bei der Konstruktion der Subklasse TurnTurtle
müssen beim Ableiten der Subklasse PathTurnTurtle eine neue Instanzvariable (double totalPath;) zur Speicherung des Gesamtweges
angelegt werden und die Methoden fd und bk um das Aufsummieren der Strecken erweitert werden und neue Methoden zum Initialisieren bzw. Rückgeben der Gesamtweglänge (resetPath, getTotalPath)
ergänzt werden.
Schreiben Sie ergänzend (entspr. Example31) ein passendes Programm,
das mit der Klasse PathTurnTurtle arbeitet.
6
In der frewiwilligen Zusatzaufgabe TA 3.6 mögen Interessierte dann
zudem (durch erneute extension) auch die beim Lauf umschlossene
Fläche berechnen.
TA 3.2
Das folgende Programmbeispiel dient im Wesentlichen dazu, Sie mit den
Elementen bekannt zu machen, die für die Bearbeitung der nachfolgenden
Aufgaben gebraucht werden:
Dazu zählt die Steuerung der Turtle durch einen Zufallszahlengenerator. Er
legt je Schritt zufällig den Winkel ihrer Drehung, die Länge der geradlinig zurückzulegenden Strecke oder auch beide fest. Hier im Beispiel dreht
sich die Turtle zufällig in den Winkelbereichen LEFT und RIGHT von 20◦
um den Ausrichtungswinkel 0◦ bis 360◦ und vollführt nach jeder Drehung
einen Schritt konstanter Länge. Für die zufällige Drehung wird die in Java vorgegebene Klasse Random genutzt. Ihre Instanzmethoden geben über
nextDouble gleichverteilte Pseudo-Zufallszahlen im Bereich von 0.0 bis 1.0
vom Datentyp double zurück.
Im Weiteren wird in diesem Programmbeispiel gezeigt, wie mit einer whileSchleife die Summe der Turtle-Bewegungen kontrolliert und terminiert wird.
Nach Überschreiten einer maximal vorgegebenen Distanz der Turtle vom
Startpunkt terminiert der Algorithmus.
In Java stehen drei Schleifenvarianten zur Verfügung:
• Die while-Schleife dient der Wiederholung von Anweisungen, solange
ein logischer Ausdruck (Ergebnistyp boolean) wahr (true) ist, z.B.:
sum = 0;
anz = 1;
while (anz <= 5)
{
sum = sum + anz;
anz++;
}
Ist die Bedingung bereits bei der ersten Püfung “false”, so werden die
Anweisungen im Rumpf der Schleife gar nicht ausgeführt.
• In der for-Schleife kann ein Anweisungsblock mit einer bestimmten Anzahl von Wiederholungen bearbeitet werden (s. auch Aufgabenblock 1,
7
TA 1.3). Zu Beginn der Schleifenbearbeitung wird eine Zählervariable
initialisiert, nach jedem Durchlauf (zumeist) um 1 erhöht/vermindert
(Inkrement/Dekrement) bis schließlich die Wiederholungsbedingung
nicht mehr greift.
sum = 0;
for (int anz = 1; anz <= 5; anz++)
{
sum = sum + anz;
}
In Java können im Initialisierungsteil und im Inkrementierungs- bzw.
Dekrementierungsteil auch jeweils mehrere Anweisungen stehen.
• In solchen Fällen, wo in einer Schleife statt einer “Eintrittsbedingung”
von der Logik eine “Austrittsbedingung” benötigt wird, steht die dowhile Schleife zur Verfügung. In ihr wird der Rumpf mindestens einmal
ausgeführt, z.B.:
sum = 0;
anz = 1;
do
{
sum = sum + anz;
anz++;
}
while (anz <= 5);
Wird in Java eine Schleife benötigt, die einen Anweisungsblock solange
wiederholt ausführt, bis eine bestimmte Bedingung erfüllt ist (im Sinne
von: repeat ... until), so muß die Bedingung in der while-Sequenz
negiert werden (Zeichen: !), z.B.:
do { ... } while (!Bedingung);.
Informieren Sie sich ergänzend über die Klasse Random im Paket java.util
und über die in Java bereitgestellten Varianten von Schleifen.
8
KlasseRandomTurtlea
a
http://www.wire.tu-bs.de/EIP/ha/ha3/RandomTurtle.java
oder im Pool unter ∼/EIP/ha/ha3/RandomTurtle.java
ProgrammExample32a
a
http://www.wire.tu-bs.de/EIP/ha/ha3/Example32.java
oder im Pool unter ∼/EIP/ha/ha3/Example32.java
9
Aufgaben:
1. Verdeutlichen Sie sich die Funktionsweise von Example32.java. Experimentieren Sie dazu mit einigen Parametern: Wählen Sie die maximalen Drehwinkelbereiche RIGHT und LEFT zu anderen Werten als den
vorgegeben (z.B. 90, 90 oder 10, 10 und 40, 20) und/oder die maximale
Entfernung vom Startpunkt MAXDIS zu größeren oder kleineren Werten als dem gegebenen Wert 400 und variieren Sie den Startpunkt der
Turtle.
2. Modifizieren Sie (durch Abändern) das Beispielprogramm so, daß die
geraden Strecken von ihrer Länge auch per Zufallszahlengenerator (im
Bereich 1 bis 50) bestimmt werden. Wiederholen Sie dabei die Variationen der Drehwinkelbereiche RIGHT und LEFT der Turtle wie im
vorangegangenen Aufgabenteil. Die Kontrollbedingung soll in dieser
Modifikation im Gegensatz zur gezeigten abweisenden Schleife
while(Bedingung) {
...
}
durch eine zumindest einmal durchlaufene Schleife
do {
...
} while (Bedingung);
realisiert werden. Machen Sie sich den Unterschied in den Schleifenvarianten klar!
3. Fügen Sie schließlich eine andere Kontrollbedingung ein, die den Algorithmus dann terminiert, wenn die Turtle (wie bisher) eine vorgegebene maximale Distanz vom Startpunkt überschreitet (“Heimweh”)
oder (ergänzend) eine Gesamtwegstrecke zurückgelegt hat, die ihre vorgegebene maximale Laufleistung übertrifft (“Ermüdung”) oder
(ergänzend) einen maximal vorgegebenen Gesamt-Drehwinkelbereich
als Folge aller einzelnen Drehungen überschreitet (“Schwindelgefühl”).
10
TA 3.3
In Erweiterung der Teilaufgabe 3.2 wird aus der zufällig sich drehenden und
vorwärts laufenden Turtle eine nach dem (im Turtlescreen plazierten) Futter
“suchenden” Turtle abgeleitet. Dabei soll die Turtle ihre Bewegungsstrategie
nach der Intensität des Futtergeruchs richten. Die Intensität des Futtergeruchs wird dabei durch die Distanz zwischen Turtle und Futter simuliert
(kurze Distanz: hoher Intensitätsgrad; weite Distanz: geringer Intensitätsgrad). Bei kürzer gewordener Distanz (entspricht steigender Geruchsintensität) fährt sie fort, geradewegs in gleicher Richtung zu gehen, bei größer
gewordener Distanz (entspricht fallender Geruchsintensität), dreht sie sich
zufällig in eine andere Richtung und fährt mit dem Suchprozeß fort. Die
Klasse SmellTurtle besitzt zwei neue Methoden:
smell(int foodx, int foody) zur Berechnung der Distanz zum Futter
und
smellStep(int foodx, int foody, double left, double right,
double length, double disold)),
eine Methode, die die Turtle bewegt und die Distanz zum Futter zurückgibt.
11
KlasseSmellTurtlea
a
http://www.wire.tu-bs.de/EIP/ha/ha3/SmellTurtle.java
oder im Pool unter ∼/EIP/ha/ha3/SmellTurtle.java
12
ProgrammExample33a
a
http://www.wire.tu-bs.de/EIP/ha/ha3/Example33.java
oder im Pool unter ∼/EIP/ha/ha3/Example33.java
Aufgaben:
1. Machen Sie sich mit dem Beispiel Example33 und der SmellTurtle
vertraut und experimentieren Sie mit einigen Parametern wie dem
Verändern der Schrittweite, dem zugelassenen Drehwinkel und der Abstandsbedingung zum Erreichen des Futters. Gewinnen Sie einen Eindruck davon, wie sich die einzelnen Parameter (schmaler/breiter zugelassener Drehwinkel, Abstandsbedingung zum Erreichen des Futters
etc.) im Mittel auf die Anzahl der von der Turtle benötigten Schritte,
zurückgelegten Wegstrecken und durchlaufenen Drehwinkel auswirken.
Schreiben Sie geeignete Ausgabeanweisungen.
2. Schreiben Sie nach ähnlichem Muster wie die gezeigte Futter suchende SmellTurtle eine Futter suchende SpähTurtle (engl. “PeerTurtle”). Diese PeerTurtle soll solange vorwärts gehen, wie das Futter
in einem vorgegebenen Spähwinkel (gamma) um ihren momentanen
Winkel der Ausrichtung β liegt. Entschwindet das Futter aus der
Ausrichtung β± Spährichtung γ, so soll die PeerTurtle sich wie die
Smellturtle zufällig drehen und den Suchprozeß fortsetzten. Wiederholen Sie die Experimente bezüglich der im Mittel benötigten Schritte,
gesamt zurückgelegten Weglängen und Drehwinkel der Turtle bis zum
Erreichen der Beute in Abhängigkeit von Parametern wie der Weite
des Spähwinkels und der Abstandsbedingung zum Erreichen des Futters etc.
Hinweise:
Die folgende Abbildung verdeutlicht die Zusammenhänge zwischen den Winkeln α, β und γ:
(0, 0): Ursprung des Turtle-screen-Koordinatensystems
F : Ort des Futters
T : Momentaner Standpunkt der Turtle (x1,y1)
α: Momentaner Winkel zwischen Futter und Turtle
β: Momentaner Ausrichtungswinkel der Turtle
±γ: “Spähwinkel” der Turtle
(0,0)
x
x
T
-
x
T
F
α
γ
y - y
F
T
γ
α
F
y
Abbildung 1: Turtle, Futter, Spähbereich
14
β
α errechnet sich aus den Koordinaten von Futter und Turtle wie folgt:
α=
180
· M ath.atan2(xT − xF , yF − yT )
M ath.P I
Math.atan2(y,x) liefert den Winkel im Bogenmaß, dessen Tangens y/x ist.
Es berücksichtigt automatisch die Vorzeichen von x und y zur Ermittlung
des richtigen Quadranten und den Sonderfall x = 0. (Anm.: Definieren Sie
für den Ausdruck 180/Math.PI eine Konstante).
Wie aus der Abbildung 1 zu entnehmen ist, sieht die Turtle das Futter wenn
gilt:
β − γ < α + 180 < β + γ
d.h. allgemein immer dann wenn
|α + 180 − β| < γ.
Um den Absolutbetrag eines arithmetischen Ausdrucks zu berechnen wird
in Java Math.abs(Ausdruck); aufgerufen.
TA 3.4
Aufgaben:
Schreiben Sie ein Programm, das zwei Turtles (zwei Farben) im Turtlescreen
zeigt. Eine Turtle sei die Beute-Turtle, die andere die Räuber-Turtle.
1. Nehmen Sie die sich zufällig drehende RandomTurtle aus TA 3.2 als
Beute und die SmellTurtle aus TA 3.3 als Räuber. Der Räuber “riecht”
sein Futter jeweils an der momentanen Position der Beute-Turtle.
Beute- und Räuber-Turtle bewegen sich immer abwechselnd.
2. Nehmen Sie die PeerTurtle aus TA 3.3.2 als Beute und die SmellTurtle
aus TA 3.3.1 als Räuber. Wie oben “riecht” der Räuber sein Futter
jeweils an der momentanen Position der Beute-Turtle. Beachten Sie
aber, daß bei der PeerTurtle als Beute das Ausrichtungsverhalten
nicht zufällig ist (wie bei der RandomTurtle) sondern auf Flucht gerichtet sein muß, d.h. umgekehrt arbeiten muß, als das Ausrichtungsverhalten der RäuberTurtle! Experimentieren Sie mit den Parametern
Schrittweite, Spähwinkel, Drehwinkel so, daß der Räuber die Beute
fangen kann. Beute- und Räuber-Turtle bewegen sich wie zuvor immer abwechselnd.
15
TA 3.5
In den soweit behandelten Beispielen wurde immer wieder die in Java integrierte Dokumentationsmethode eingesetzt.
Aufgabe:
Starten Sie nun zur Erstellung eines HTML-Dokumentes das Programm
javadoc für die vorgegebenen Example31.java, Example32.java und die
von Ihnen bearbeitete TA 3.4 jeweils gesondert nach folgendem Muster an:
javadoc -author -version Example31.java.
Sehen Sie sich die von Ihnen erstellte Dokumentation ihres Javaprogramms
mit einem Browser an.
TA 3.6 (Freiwillige Zusatzaufgabe für Interessierte)
Diese Aufgabe ergänzt die TA 3.1 um ein weiteres Beispiel zur Vererbung
und Erweiterung einer Super-/Basisklasse.
Aufgabe:
1. Die Klasse PathTurnTurtle (aus TA 3.1) soll noch einmal durch Vererbung erweitert werden (zur Subklasse AreaPathTurnTurtle), sodaß
sie auch die von der Turtle bei geschlossenen geometrischen Figuren
umlaufene Fläche berechnet (s. dazu Abb 2 und die “Erläuterung zur
Berechnung der Fläche”). Eine neue Instanzvariable zur Speicherung
der umlaufenen Fläche und die Erweiterung der Methoden fd und bk
um das Aufsummieren der Flächen sind dazu nötig.
Verwenden Sie anschließend die Klasse AreaPathTurnTurtle in einem
Programm, in dem die Turtle sich zum einen um ein nEck (mit n =
3 und 8) und zum anderen um die Koch-Kurve bewegt und dabei den
Gesamtdrehwinkel, die Gesamtlaufstrecke und die Fläche der umlaufenen Figuren ermittelt.
Anm.:
Ziehen Sie dazu die in den Aufgabenblöcken TA 2.2 und TA 2.3 erarbeiteten Programmsequenzen (Methoden)zum Umlaufen entsprechender Figuren hinzu.
Erläuterung zur Berechnung der Flächen:
16
(x1,y1)
2. Teilflaeche
11111
00000
00000000000000
0000011111111111111
11111
00000000000000
11111111111111
00000
11111
00000000000000
0000011111111111111
11111
00000000000000
11111111111111
00000
11111
00000000000000
0000011111111111111
11111
00000000000000
11111111111111
00000
11111
00000000000000
11111111111111
0000011111111111111
11111
00000000000000
00000
11111
00000000000000
b
0000011111111111111
11111
00000000000000
11111111111111
00000
11111
00000000000000
11111111111111
00000
11111
00000000000000
11111111111111
00000
11111
00000000000000
11111111111111
a
00000
11111
00000000000000
0000011111111111111
11111
00000000000000
11111111111111
00000
11111
00000000000000
11111111111111
00000
11111
00000000000000
0000011111111111111
11111
00000000000000
11111111111111
(x2,y2)
(x2,y2)
1. Teilflaeche
(x1,y1)
(startx,starty)
Abbildung 2: Flächenberechnung
Die Turtle kann auf einen Startpunkt gesetzt werden durch Aufruf von
t.setPosition(startx, starty). Die Koordinaten einer Turtle-Position
können abgefragt werden durch getX() und getY().
Nun kann man die Fläche einer von der Turtle umlaufenen Figur dadurch
errechnen, daß man die Summe aller eingeschlossenen Dreiecks-Teilflächen
addiert (s. Abb. 2). Zur Bestimmung einer Dreiecks-Teilfläche gilt folgende
Rechenvorschrift:
|f | =
1
· (x1 − startx) · (y2 − starty) − (y1 − starty) · (x2 − startx) · e3
2
Der Startpunkt (startx, starty) bleibt je Teilfläche erhalten, (x1,y1)
und (x2,y2) werden je Schritt “vorangeschoben” (s. Abb. 2). Bei der Errechnung der Teilflächen ergeben sich automatisch positive oder negative
Werte, je nachdem ob sich die Turtle ausgehend von der letzten Position
rechts oder linksdrehend weiter bewegt hat.
17