Tutoraufgabe 1 (FunctionalSet):

Transkript

1 Prof. aa Dr. J. Giesl Programmierung WS12/13 M. Brockschmidt, F. Emmes, C. Otto, T. Ströder Tutoraufgabe 1 (FunctionalSet): In dieser Aufgabe geht es um die Implementierung einer Datenstruktur für Mengen, welche in das bestehende Collections Framework eingebettet werden soll. Sie benötigen dafür die abstrakten Klassen AbstractIterableSet und SimpleFunctionalSet, welche Sie als.java Dateien von unserer Webseite herunterladen können. Alle in dieser Aufgabe zu implementierenden Klassen sollen nicht abstrakt sein und die beiden vorgegebenen abstrakten Klassen sollen nicht verändert werden. Die in dieser Aufgabe zu implementierende Mengenstruktur basiert auf einer Liste von Einfüge- (Add) und Löschoperationen (Remove) mit jeweils einem Element, die vom Ausgangspunkt einer leeren Menge (Empty) angewendet werden. Zum Beispiel lässt sich die Menge {1, 2, 3 als die Liste Add 3, Add 2, Add 1, Empty darstellen. Will man nun das Element 2 aus der Menge löschen, so entfernt man nicht das zweite Element aus der Liste, sondern fügt ein weiteres Remove Element hinzu und erhält Remove 2, Add 3, Add 2, Add 1, Empty. Auf diese Weise erhält man eine Datenstruktur, bei der niemals Objekte entfernt werden (mit Ausnahme der clear Methode, welche die Liste wieder auf Empty setzen soll). Eine solche Mengendarstellung nennt man auch funktional, da die Einfüge- und Löschoperationen als Funktionen aufgefasst werden können, welche auf die leere Menge angewendet werden. a) Schreiben Sie eine generische Klasse EmptySet<E> als Unterklasse von SimpleFunctionalSet<E>. Die zu implementierende contains Methode soll immer false zurückgeben. Achten Sie darauf, dass Sie einen Konstruktor explizit angeben müssen (das set Attribut der leeren Menge soll null sein). b) Schreiben Sie eine generische Klasse AddSet<E> als Unterklasse von SimpleFunctionalSet<E>. Diese Klasse soll ein Attribut element vom Typ E besitzen, auf welches über eine Getter-Methode (d. h. einen geeigneten Selektor) zugegriffen werden kann. Die zu implementierende contains Methode soll true zurückgeben, falls sowohl element als auch das übergebene Objekt o null sind oder der Test element.equals(o) erfolgreich ist. Ansonsten soll die Methode contains rekursiv von der verbleibenden Menge (über die Methode getremainingset zugreifbar) aus mit dem gleichen Argument aufgerufen werden. Achten Sie auch hier darauf, dass Sie einen passenden Konstruktor explizit angeben müssen und beachten Sie die Prinzipien der Datenkapselung. c) Schreiben Sie eine generische Klasse RemoveSet<E> als Unterklasse von SimpleFunctionalSet<E>. Diese Klasse soll ein Attribut obj vom Typ Object besitzen, auf welches über eine Getter-Methode zugegriffen werden kann. Die zu implementierende contains Methode soll false zurückgeben, falls sowohl element als auch das übergebene Objekt o null sind oder der Test obj.equals(o) erfolgreich ist. Ansonsten soll die Methode contains rekursiv von der verbleibenden Menge (über die Methode getremainingset zugreifbar) aus mit dem gleichen Argument aufgerufen werden. Achten Sie auch hier darauf, dass Sie einen passenden Konstruktor explizit angeben müssen und beachten Sie die Prinzipien der Datenkapselung. d) Schreiben Sie eine generische Klasse FunctionalSet<E> als Unterklasse von AbstractIterableSet<E>. Diese soll genau ein Attribut head vom Typ SimpleFunctionalSet<E> besitzen. Da die Oberklasse das Set Interface aus dem Package java.util implementiert, muss Ihre Klasse die noch fehlenden Methoden add, clear, contains, iterator und remove implementieren. Schlagen Sie die zu implementierenden Funktionalitäten dieser Methoden in der Java API für das Interface Set nach und nutzen Sie die in den vorigen Teilaufgaben implementierten Klassen. Ihre Implementierung soll das Hinzufügen beliebiger Elemente (inklusive null) unterstützen. Außerdem soll (wie am Anfang der Aufgabe beschrieben) außer durch die clear Methode kein SimpleFunctionalSet Objekt aus der Liste dieser Objekte entfernt werden. Implementieren Sie für die iterator Methode eine weitere generische Klasse FunctionalSetIterator<E>, welche das Interface Iterator<E> aus dem Package java.util implementiert. Schlagen Sie auch hier für die zu implementierenden Methoden hasnext, next und remove die Funktionalitäten in der Java API für das Interface Iterator nach (die remove Operation soll durch Ihren Iterator unterstützt werden). Zum Testen Ihrer Implementierung können Sie die Datei SetTest.java von unserer Webseite benutzen. Der Aufruf Ihrer main Methode sollte folgende Ausgabe auf der Konsole erzeugen: { {1 {2,1 1

2 {3,2,1 {3,2,1 {3,2 {3 {3 { {null {1 {2,1 {2,1 {2,1 {2 {2 {5,2,3,null {5,2,3,null {5,3,null {5,3,null {5,3 Lösung: Listing 1: AddSet.java * Simple functional set adding an element to another simple functional set. public class AddSet <E> extends SimpleFunctionalSet <E> { * The element to add. private final E element ; elem The element to add. s The remaining set. public AddSet ( final E elem, final SimpleFunctionalSet <E> s) { super (s); this. element = elem ; public boolean contains ( final Object o) { if ( this. element == null ) { if (o == null ) { else { return this. getremainingset (). contains (o); else if ( this. element. equals (o)) { else { return this. getremainingset (). contains (o); The element to add. public E getelement () { return this. element ; Listing 2: EmptySet.java * Simple functional set containing no element. public class EmptySet <E> extends SimpleFunctionalSet <E> { * Creates an empty simple functional set. 2

3 public EmptySet () { super ( null ); public boolean contains ( final Object o) { import java. util.*; Listing 3: FunctionalSet.java * public class FunctionalSet <E> extends AbstractIterableSet <E> { * The head of the list of operations representing the set. private SimpleFunctionalSet <E> head ; * Creates an empty functional set. public FunctionalSet () { this. head = new EmptySet <E >(); public boolean add ( final E e) { if ( this. contains (e)) { else { this. head = new AddSet <E>(e, this. head ); public void clear () { this. head = new EmptySet <E >(); public boolean contains ( final Object o) { return this. head. contains (o); public Iterator <E> iterator () { return new FunctionalSetIterator <E>( this, this. head ); public boolean remove ( final Object o) { if ( this. contains (o)) { this. head = new RemoveSet <E>(o, this. head ); else { import java. util.*; Listing 4: FunctionalSetIterator.java * Iterator through a functional set. public class FunctionalSetIterator <E> implements Iterator <E> { 3

4 * The current simple functional set. It is always an add set with an unused (i.e., not contained in * the set named " used " below ) element or an empty set. private SimpleFunctionalSet <E> current ; * The most recent element this iterator has returned. private E recentelem ; * Flag indicating whether the remove operation is applicable ( needed since elements may be null, so * we cannot just check whether recentelem is null ). private boolean removable ; * The functional set to which the current simple functional set belongs. private final FunctionalSet <E> set ; * A set of already seen elements ( in add or remove sets ). private final Set <Object > used ; functionalset The functional set containing the simple functional set to iterate over. head The head of the simple functional set to iterate over. public FunctionalSetIterator ( final FunctionalSet <E> functionalset, final SimpleFunctionalSet <E> head ) { this. current = head ; this. recentelem = null ; this. removable = false ; this. set = functionalset ; this. used = new FunctionalSet < Object >(); this. forwardtonextunusedset (); public boolean hasnext () { return!( this. current instanceof EmptySet ); public E next () { if ( this. hasnext ()) { final E elem = (( AddSet <E>) this. current ). getelement (); this. used. add ( elem ); this. recentelem = elem ; this. removable = true ; this. current = this. current. getremainingset (); this. forwardtonextunusedset (); return elem ; else { throw new NoSuchElementException (); public void remove () { if ( this. removable ) { this. set. remove ( this. recentelem ); this. removable = false ; else { throw new IllegalStateException ( " The next method has not been called before this remove operation!"); * Forwards the current set to the next remaining set which is no remove set and which is no add set * with an already used element. During forwarding, used objects are added to the corresponding set. private void forwardtonextunusedset () { boolean loop = true ; while ( loop ) { loop = false ; while ( this. current instanceof RemoveSet ) { 4

5 this. used. add ((( RemoveSet <E>) this. current ). getobject ()); this. current = this. current. getremainingset (); if ( this. current instanceof AddSet && this. used. contains ((( AddSet <E>) this. current ). getelement ())) { loop = true ; this. current = this. current. getremainingset (); Listing 5: RemoveSet.java * Simple set removing an object from another simple set. public class RemoveSet <E> extends SimpleFunctionalSet <E> { * The object to remove. private final Object obj ; o The object to remove. s The remaining set. public RemoveSet ( final Object o, final SimpleFunctionalSet <E> s) { super (s); this. obj = o; public boolean contains ( final Object o) { if ( this. obj == null ) { if (o == null ) { else { return this. getremainingset (). contains (o); else if ( this. obj. equals (o)) { else { return this. getremainingset (). contains (o); The object to remove. public Object getobject () { return this. obj ; Aufgabe 2 (FlagSet): ( = 17 Punkte) In dieser Aufgabe geht es um die Implementierung einer Datenstruktur für Mengen, welche in das bestehende Collections Framework eingebettet werden soll. Sie benötigen dafür die abstrakte Klasse AbstractIterableSet, welche Sie als.java Datei von unserer Webseite herunterladen können. Alle in dieser Aufgabe zu implementierenden Klassen sollen nicht abstrakt sein und die vorgegebene abstrakte Klasse soll nicht verändert werden. Die in dieser Aufgabe zu implementierende Mengenstruktur basiert auf einer Liste von Elementen mit einer active Markierung vom Typ boolean. Nur solche Elemente sind in der Menge enthalten, deren active Markierung den Wert true hat. Um Elemente aus der Menge zu löschen, sollen keine Objekte aus dieser Liste entfernt, sondern lediglich die entsprechende Markierung auf false gesetzt werden. Um Duplikate zu vermeiden, soll beim Einfügen die Liste durchsucht werden und für ein ggf. bereits gelöschtes Element, das wieder eingefügt wird, soll kein neues Objekt angelegt, sondern seine Markierung wieder auf true gesetzt werden. Zum Beispiel kann die Menge {1, 2, 3 als die Liste 3 true, 2 true, 1 true dargestellt werden. 5

6 Löscht man nun das Element 2, so ist die resultierende Menge durch die Liste 3 true, 2 false, 1 true dargestellt. Ein erneutes Einfügen des Elementes 2 liefert wieder die ursprüngliche Liste. Natürlich soll beim Einfügen eines Elementes, für das es bereits ein mit true markiertes Element in der List gibt, keine Modifikation an der Liste vorgenommen werden (analog beim Löschen eines Elements, für das es ein mit false markiertes oder gar kein Element in der Liste gibt). Lediglich die clear Methode soll also tatsächlich Objekte aus der Liste entfernen können. a) Schreiben Sie eine generische Klasse SetNode<E> mit drei Attributen active vom Typ boolean, element vom Typ E und next vom Typ SetNode<E>. Implementieren Sie Getter-Methoden für alle Attribute und ermöglichen Sie beliebige Veränderungen am Attribut active (beachten Sie dabei die Prinzipien der Datenkapselung). b) Schreiben Sie eine generische Klasse FlagSet<E> als Unterklasse von AbstractIterableSet<E>. Diese soll genau ein Attribut head vom Typ SetNode<E> besitzen. Da die Oberklasse das Set Interface aus dem Package java.util implementiert, muss Ihre Klasse die noch fehlenden Methoden add, clear, contains, iterator und remove implementieren. Schlagen Sie die zu implementierenden Funktionalitäten dieser Methoden in der Java API für das Interface Set nach und nutzen Sie die in der vorigen Teilaufgabe implementierte Klasse SetNode. Ihre Mengenimplementierung soll das Hinzufügen von beliebigen Elementen (inklusive null) unterstützen und nur dann ein neues SetNode Objekt anlegen, wenn ein Element in eine Menge eingefügt wird (mittels der add Methode), das noch nie seit dem letzten Aufruf der clear Methode in dieser Menge enthalten war. Außerdem soll außerhalb der clear Methode kein SetNode Objekt aus der mit dem head Attribut startenden Liste von SetNode Objekten entfernt werden. Benutzen Sie stattdessen die active Markierungen in den SetNode Objekten wie am Anfang dieser Aufgabe beschrieben. Implementieren Sie für die iterator Methode eine weitere generische Klasse FlagSetIterator<E>, welche das Interface Iterator<E> aus dem Package java.util implementiert. Schlagen Sie auch hier für die zu implementierenden Methoden hasnext, next und remove die Funktionalitäten in der Java API für das Interface Iterator nach (die remove Operation soll durch Ihren Iterator unterstützt werden). Zum Testen Ihrer Implementierung können Sie ebenfalls die Datei SetTest.java von unserer Webseite benutzen, indem Sie alle Vorkommen von FunctionalSet durch FlagSet ersetzen. Der Aufruf Ihrer main Methode sollte die gleiche Ausgabe wie in der vorigen Tutoraufgabe erzeugen. Hinweise: Für den Iterator könnte es hilfreich sein, jeweils ein Attribut für das nächste zurückzuliefernde und das letzte zurückgelieferte Element zu verwenden. Lösung: import java. util.*; Listing 6: FlagSet.java * public class FlagSet <E> extends AbstractIterableSet <E> { * The first set node of this set. private SetNode <E> head ; * Creates an empty FlagSet. public FlagSet () { this. head = null ; public boolean add ( final E e) { SetNode <E> current = this. head ; while ( current!= null ) { final E elem = current. getelement (); 6

7 if ( elem == null ) { if (e == null ) { if ( current. isactive ()) { else { current. activate (); else if ( elem. equals (e)) { if ( current. isactive ()) { else { current. activate (); current = current. getnext (); this. head = new SetNode <E>(e, this. head ); public void clear () { this. head = null ; public boolean contains ( final Object o) { for ( final E elem : this ) { if ( elem == null ) { if (o == null ) { else if ( elem. equals (o)) { public Iterator <E> iterator () { return new FlagSetIterator <E>( this. head ); public boolean remove ( final Object o) { SetNode <E> current = this. head ; while ( current!= null ) { final E elem = current. getelement (); if ( elem == null ) { if (o == null ) { if ( current. isactive ()) { current. deactivate (); else { else if ( elem. equals (o)) { if ( current. isactive ()) { current. deactivate (); else { current = current. getnext (); import java. util.*; Listing 7: FlagSetIterator.java 7

8 * Iterator through a FlagSet. public class FlagSetIterator <E> implements Iterator <E> { * The current active node. private SetNode <E> current ; * The most recent active node. This is null if the next () method has not been called since the last * remove operation. private SetNode <E> recent ; head The start node. public FlagSetIterator ( final SetNode <E> head ) { this. current = head ; this. recent = null ; this. forwardtonextactivenode (); public boolean hasnext () { return this. current!= null ; public E next () { if ( this. hasnext ()) { final E res = this. current. getelement (); this. recent = this. current ; this. current = this. current. getnext (); this. forwardtonextactivenode (); return res ; else { throw new NoSuchElementException (); public void remove () { if ( this. recent == null ) { throw new IllegalStateException ( " The next method has not been called before this remove operation!"); else { this. recent. deactivate (); this. recent = null ; * Forwards the current node to the next active node. private void forwardtonextactivenode () { while ( this. current!= null &&! this. current. isactive ()) { this. current = this. current. getnext (); * public class SetNode <E> { Listing 8: SetNode.java * Flag indicating activeness of the element. private boolean active ; * The element. private final E element ; 8

9 * The next node. private final SetNode <E> next ; * Creates an active set node. elem The element. n The next node. public SetNode ( final E elem, final SetNode <E> n) { this. element = elem ; this. next = n; this. active = true ; * Sets the element active. public void activate () { this. active = true ; * Sets the element inactive. public void deactivate () { this. active = false ; The element. public E getelement () { return this. element ; The next node. public SetNode <E> getnext () { return this. next ; True iff the element is active. public boolean isactive () { return this. active ; Aufgabe 3 (Phantom Types): Helfen Sie dem Weihnachtsmann! Aufgrund der stetig wachsenden Erdbevölkerung hat der Weihnachtsmann keine Zeit mehr, um Geschenke noch direkt in die Häuser zu tragen. Stattdessen muss er auf eine effizientere Methode der Verteilung ausweichen. Sein Plan: Die Geschenke schon während dem Flug aus dem Rentierschlitten fallen zu lassen, so dass sie im richtigen Schornstein landen. Hierfür muss der Weihnachtsmann den genauen Zeitpunkt wissen, zu dem er das Geschenk loslassen muss. Ihre Aufgabe: Implementieren Sie eine Methode, die berechnet, wieviele Meter vor der Überquerung des Schornsteins das Geschenk fallen gelassen werden muss. ( = 11 Punkte) s h 9

10 Damit bei der Berechnung mit physikalischen Formeln weniger Fehler passieren, bietet es sich an, physikalische Einheiten durch Java Typen abzubilden. Hierdurch kann der Compiler überprüfen, ob die Formel auf Werte mit korrekten Einheiten angewendet wird. Wie das genau funktioniert, soll durch diese Aufgabe erläutert werden. a) Definieren Sie ein Interface Einheit, welches wie alle Interfaces dieser Aufgabe keine Methoden enthält. Definieren Sie nun die Interfaces Meter und Sekunden, welche Einheit erweitern. Definieren Sie außerdem die Interfaces Multiplikation und Division, welche jeweils zwei generische Typ-Parameter bekommen, die Einheit erweitern. Multiplikationen und Divisionen von Einheiten sind ebenfalls Einheiten. Nun können Sie die in dieser Aufgabe benötigten Einheiten als Java Typen darstellen: Einheit Bedeutung Java Typ m Strecke Meter s Dauer Sekunden m/s Geschwindigkeit Division<Meter, Sekunde> m/s 2 Beschleunigung Division<Meter, Multiplikation<Sekunde,Sekunde>> Da es keine Klassen gibt, die diese Interfaces implementieren (und somit auch keine entsprechenden Objekte), nennt man solche Typen auch phantom types. b) Schreiben Sie die Klasse Wert, welche einen double-wert kapselt und per Selektor zur Verfügung stellt. Diese Klasse bekommt einen generischen Typ-Parameter, der das Interface Einheit erweitern soll. Ein Objekt, welches eine Strecke von 10 m repräsentieren soll, hat also den Typ Wert<Meter> und kapselt den double Wert c) Erstellen Sie eine Klasse Physik. Definieren Sie eine statische Methode berechnefalldauer in der Klasse Physik, welche eine Strecke h (in Metern) sowie eine Beschleunigung g (in Metern pro Sekunde zum Quadrat) übergeben bekommt und die Dauer (in Sekunden) zurückgibt, die ein Gegenstand braucht, um aus einer solchen Höhe geworfen am Boden anzukommen, wenn die Beschleunigung g auf ihn wirkt. 2h Die Formel zur Berechnung der Falldauer t lautet t = g. Verwenden Sie (auch in den Methoden der folgenden Aufgabenteilen) für die Parameter und den Rückgabewert den Typ Wert mit korrekten Einheiten. d) Definieren Sie eine statische Methode berechnestrecke in der Klasse Physik, welche eine Geschwindigkeit v (in Metern pro Sekunde), sowie eine Zeit t (in Sekunden) übergeben bekommt und die Strecke (in Metern) berechnet, die ein Gegenstand mit der Geschwindigkeit v in der Zeit t zurücklegt. e) Definieren Sie eine statische Methode berechneabwurfentfernung in der Klasse Physik, welche eine Strecke h (in Metern, Flughöhe des Rentierschlittens über dem Schornstein) und eine Geschwindigkeit v (in Metern pro Sekunde, Geschwindigkeit des Schlittens) übergeben bekommt und berechnet, in welcher Entfernung s der Weihnachtsmann ein Geschenk fallen lassen muss, damit es im Schornstein landet. Nehmen Sie hierzu an, dass sich das Geschenk in Fahrtrichtung mit gleichbleibender Geschwindigkeit fortbewegt, dabei aber nach unten fällt. Die Erdbeschleunigung beträgt 9, 81 m/s 2. Lösung: public interface Einheit { public interface Meter extends Einheit { Listing 9: Einheit.java Listing 10: Meter.java 10

11 public interface Sekunden extends Einheit { Listing 11: Sekunden.java Listing 12: Multiplikation.java public interface Multiplikation <E1 extends Einheit, E2 extends Einheit > extends Einheit { Listing 13: Division.java public interface Division <E1 extends Einheit, E2 extends Einheit > extends Einheit { public class Wert <E extends Einheit > { private final double wert ; Listing 14: Wert.java Wert ( double wert ) { this. wert = wert ; public double getwert () { return wert ; Listing 15: Physik.java public class Physik { public static Wert <Sekunden > berechnefalldauer ( Wert <Meter > h, Wert <Division <Meter, Multiplikation <Sekunden, Sekunden >>> g) { return new Wert <>( Math. sqrt (2 * h. getwert () / g. getwert ())); public static Wert <Meter > berechnestrecke ( Wert <Division <Meter, Sekunden >> v, Wert <Sekunden > t) { return new Wert <>(v. getwert () * t. getwert ()); public static Wert <Meter > berechneabwurfentfernung ( Wert <Meter > h, Wert <Division <Meter, Sekunden >> v) { Wert <Division <Meter, Multiplikation <Sekunden, Sekunden >>> g = new Wert <>( 9.81); Wert <Sekunden > falldauer = berechnefalldauer (h, g); Wert <Meter > strecke = berechnestrecke (v, falldauer ); return strecke ; 11