1853-E1-Lösungen - Lösung für 1. Aufgabe PDF

Preview

Summary

Lösung für 1. Aufgabe...

Description

Kurs 01853, Sommer 2020, Lösungsvorschläge zu den Aufgaben der Kurseinheit 1

Aufgabe 1: Theorieaufgabe (12 + 4 + 6 + 2 + 2 + 6 = 32 Punkte) 1.1 Mögliche Charakterisierungen: •

Interfaces als Typen (in Java und C#) anstelle von Klassen bei der Typisierung von Variablen (Variablendeklarationen)

•

Interfaces ermöglichen Polymorphismus und dynamisches Binden ohne Vererbung

•

Interfaces als Schnittstelle: Nach IEEE: gemeinsame Grenze, über die hinweg Information gereicht wird, hinter der die Klasse ihre Entwurfsentscheidungen verbergen kann (Geheimnisprinzip)

•

„Interface-Vererbung“: Interfaces sind in der Regel kein Ersatz für Mehrfachvererbung, Klassen implementieren Interfaces

•

Entkopplung durch Verwendung von Interfaces

•

Interfaces als Rollen

1.2 Nachteil: Wenn man sich in einem JAVA-Programm dazu entscheidet, ein Interface durch Aufnahme einer weiteren Methode zu erweitern (was im Rahmen der Weiterentwicklung regelmäßig vorkommt), dann läuft man Gefahr, dass die Typkorrektheit des Programms verlorengeht, nämlich dann, wenn nicht alle Klassen, die dieses Interface implementieren, auch über die zusätzliche Methode verfügen. Dies ist z. B. dann ein Problem, wenn das Interface zu einem Framework gehört und man selbst, als Entwicklerin des Frameworks, keine Kontrolle über dessen Verwendungen durch andere hat. Daher erlauben sowohl Java als auch C# die Bereitstellung von Default-Implementierung von Methoden, die vererbt werden und somit zum Einsatz kommen, solange die implementierenden Klassen keine eigenen Implementationen vorsehen. 1.3 Im Kurstext werden drei Prinzipien genannt: • Prinzip wiederverwendbaren objektorientierten Designs: „Program to an interface, not to an implementation“ • Interface Segregation Principle (im Zusammenhang mit partiellen Interfaces) • Dependency Inversion Principle (Umkehrung von Abhängigkeiten mit Interfaces) 1.4 Familieninterfaces werden in Zusammenhang mit Factories eingesetzt, auch anstelle von abstrakten Klassen, wenn die zu implementierende Klasse von anderen, nicht die Familie repräsentierenden Klassen erben soll. 1.5 Ermöglichende Interfaces finden vornehmlich in Blackbox-Frameworks Verwendung, bei denen das Aufrufen über Komposition und Delegation bzw. Forwarding erfolgt; 1.6 Anstatt wie bei der Benutzung von Programmbibliotheken üblich selbst die Ausführungssteuerung des Programms in die Hand zu nehmen und andere Klassen bei Bedarf aufzurufen, werden die Anwendungsklassen bei der Verwendung eines Frameworks in das Framework eingeklinkt (über sog. Hooks oder Plug points) und durch das Framework aufgerufen. Man nennt dies gelegentlich auch das Hollywood -Prinzip, wegen der gewerbeüblichen Ansage „don’t call us, we call you“. Bei Blackbox-Frameworks erfolgt das Aufrufen über Komposition und Delegation bzw. Forwarding, bei Whitebox-Frameworks über Vererbung und offene Rekursion.

1

Kurs 01853, Sommer 2020, Lösungsvorschläge zu den Aufgaben der Kurseinheit 1

Aufgabe 2: Arten von Interfaces (12 Punkte)

•

IA: Server/Client: Der Kommentar in den Klassen A und Stuff gibt hier einen Hinweis. Klasse A implementiert das Interface IA. Der Wert i wird aber von außen bezogen, von Klasse Stuff. Klasse A bezieht einen Service von Klasse Stuff, weil Klasse A den nicht selbst leisten kann.

•

IB: Server/Item: Klasse B implementiert das Interface. Die Klassen C und D referenzieren das Interface. Klasse B bietet keinen Service an, sondern gibt nur einen Wert zurück. Gleiches macht Klasse C. Klasse D macht etwas mit den Werten in Methode f. Die Werte kann man als Items ansehen.

•

IE: Familieninterface: Es enthält alle Methoden der Klassen FE und GE.

•

IK und IL: Client/Server: IK, IL decken jeweils nur einen Teil der Klasse ab. Es kann sich also nur um kontextspezifische Interfaces handeln und nicht um allgemeine Interfaces. Somit scheidet ideosynkratisch aus. Da aber die Klasse KL von niemandem abhängig ist und alle Berechnungen alleine macht, handelt es sich um Client/ Server Interface.

•

IM: idiosynkratisch: Es wird von einer Klasse implementiert und enthält alle Methoden, die die Klasse M zu Verfügung stellt.

Eventuelle Probleme bei der Zuordnung können entstehen, da die Interfaces, Klassen und Methoden weder sprechende Namen tragen noch in irgendeiner Weise dokumentiert sind und den Methoden auch sinnvolle Körper fehlen; die Einordnung eines Interfaces in eine bestimmte Art hängt aber vom Kontext der Benutzung ab.

2

Kurs 01853, Sommer 2020, Lösungsvorschläge zu den Aufgaben der Kurseinheit 1

Aufgabe 3: Entkoppelung von Klassen (8 + 2 = 10 Punkte) 3.1 Durch Einführung der Interfaces InputStream und OutputStream können innerhalb der Klassen StreamFiller und StreamPrinter die Parameter der Methoden mit Interfaces statt mit Klassen typisiert werden, so dass nur die benötigten Klassenmethoden der Parameter zur Verfügung stehen. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

public class StreamProcessing { public static voi void d main( String[] args ) { Stream stream = new Stream(); StreamFiller.fillStream( stream ); StreamPrinter.printStream( stream ); } } class StreamFiller { public static void fillStream( OutputStream stream ) { stream.writeString( "This is a" ); stream.writeString( " stream." ); } } class StreamPrinter { public static void printStream( InputStream stream ) { char ch = stream.readChar(); while ( ch != 0 ) { System.out.print( ch ); ch = stream.readChar(); } } } interface InputStream { char readChar(); } interface OutputStream { void writeString( String str ); } class Stream imp implements lements InputStream, OutputStream { private String content = ""; int index = 0; public char readChar() { if ( index < content.length() ) return content.charAt( index++ ); else return 0; } public void writeString( String str ) { content += str; } }

3.2 Es handelt sich um zwei partielle Client/Server-Interface.

3

Kurs 01853, Sommer 2020, Lösungsvorschläge zu den Aufgaben der Kurseinheit 1

Aufgabe 4: Dependency Injection (4 + 10 = 14 Punkte) Für dieses Beispiel wäre die Constructor Injection vorzuziehen, da die Printer-Klassen zwingend einen Stream zum Arbeiten benötigen und über den Constructor sichergestellt wird, dass sie einen erhalten. Bei Verwendung der Setter Injection ist nicht sichergestellt, dass der Setter auch irgendwann einmal aufgerufen wird – jede Methode, welche auf den Stream zugreift, muss bei jedem Aufruf also überprüfen, ob das übergebene Objekt überhaupt gültig ist. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

public class StreamProcessing { public static void main( String[] args ) { Stream stream = new Stream(); StreamFiller filler = new StreamFiller( stream ); StreamPrinter printer = new StreamPrinter(); printer.setStream( stream ); filler.fillStream(); printer.printStream(); } } class StreamFiller { OutputStream stream; public StreamFiller( OutputStream stream ) { if ( stream == null ) throw new Error( "Missing stream object in constructor" ); }

this this.stream = stream;

public void fillStream() { stream.writeString( "This is a" ); stream.writeString( " stream." ); } } class StreamPrinter { InputStream stream; public void setStream( InputStream stream ) { this this.stream = stream; } public void printStream() { if ( stream != null ) stream.apply( new Applicator() { @Override public void apply( char ch ) { System.out .print( ch ); } } ); else throw new Error( "Missing stream object in printStream call" ); } } ...

4...