Refactoring To Patterns Generalization Patterns. Einführung Ziel spezifisches Code ->...

Refactoring To Patterns

GeneralizationPatterns

Einführung

Ziel spezifisches Code -> allgemeingültigeres Code

Motivation

Beseitigung von mehrfach vorhandenes CodeVereinfachung und Verdeutlichung vom Code

Generalization Patterns

7 Patterns Form Template Method Extract Composite Replace One/Many Distinctions with Composits Replace Hard-Coded Notifications with Observer Unify Interfaces with Adapter Extract Adapter Replace implicit Language with interpreter

Form Template Method

GrundprinzipZwei Methoden in den Unterklassen führen ähnliche schritte

in der selben Reihenfolge aus.

Generalisiere diese Methoden folgender maßen:

1. Extrahiere die einzelnen Schritte zu separaten Methoden mit gleichen Signaturen2. Verlege diese generalisierten Methoden nach oben, um ein Template Methode zu bilden


GrundideeImplementiere den unveränderlichen (invarianten) Teil eines Algorithmen nur einmal und überlasse die Implementierung des veränderlichen (varianten) Teils den Unterklassen.

Unveränderlicher Teil des Algorithmus umfasst:

• Die aufzurufenden Methoden und die Reihenfolge deren Aufrufs

• Die abstrakten Methoden, die von den Unterklassen überschrieben werden müssen

• Die Hook Methoden


public class Flug extends ReiseLeistung { ... private Hashtable<String,Integer> klasse2Frei = new ... ... public boolean flugPlatzBuchen (int anzahl, String klasse){ //frage die Anzahl der noch freien Sitzplaetze in der gegebenen Klasse ab int frei = klasse2Frei.get(klasse); //wenn es nicht genuegend freie Plaetze gibt if (anzahl > frei) return false; //wenn es genuegend freie Plaetze gibt //aktualiesiere die Anzahl der noch freien plaetze klasse2Frei.put( klasse, frei – Anzahl ); //Druecke Tickets aus druckFlugTicketsAus(anzahl, klasse); return true; } ...}


public class Hotel extends ReiseLeistung { ... private Hashtable<String,Integer> kategorie2Frei = new ... ...

public boolean zimmerBuchen (int anzahl, String kategorie){ //frage die Anzahl der noch freien Zimmer in der gegebenen Kategorie ab int frei = kategorie2Frei.get(kategrie); frei -= getInReperatur(kategorie); //wenn es nicht genuegend freie Zimmer gibt if (anzahl > frei) return false; //wenn es genuegend freie Zimmer gibt //aktualiesiere die Anzahl der noch freien Zimmer kategorie2Frei.put(kategorie,frei-anzahl); //Druecke Tickets aus druckZimmerReservierungAus(anzahl,kategorie); return true; } ...}


public class ReiseLeistung { ... public abstract int getFreieKapazitaet (String kategrie); public abstract void updateFreieKapazitaet (String kategorie,int neuKapazitaet); public abstract void druckLeistungsBeleg (int anzahl, String kategorie); ...

public boolean buchen (int anzahl, String kategorie){ int frei = getFreieKapazitaet(kategrie); if (anzahl > frei) return false; updateFreieKapazitaet(kategorie,frei-anzahl); druckLeistungsBeleg(anzahl, kategorie); return true; } ...}


Prozedur1. Compose Method in den Unterklassen anwenden, um identische

Methoden (gleiche Signatur und Implementierung) und unique Methoden (Methoden die unterschiedliche Signatur/Implementierung in jeder Unterklasse haben) zu erzeugen.

2. Pull Up Method an allen identischen Methoden anwenden, um diese Methoden in die Basisklasse zu verlagern.

3. Rename Method an allen unique Methoden anwenden, um identische Signatur in jeder Unterklasse herzustellen.

4. Rename Methode anwenden, falls die zukünftige Template-Methode in allen Unterklassen gleiche Signatur besitzt.

5. Pull Up Method anwenden, um die Template-Methode in die Basisklasse zu verlagern und abstracte Methoden für unique Methoden in der Basisklasse definieren.


Vorteile•Beseitigt mehrfach vorhandenes Code in Unterklassen durch

Verlagerung vom gemeinsamen, unveränderlichen Teil des

Algorithmus in die Basisklasse•Vereinfachung des Codes und bessere Kommunikation durch Verdeutlichung der im generischen Algorithmus enthaltenen Schritte•Vereinfachte Anpassung in den Unterklassen durch Überschreibung der abstrakten Methoden in den Unterklassen

NachteilKomplizierteres Design, wenn Unterklassen viele abstrakte Methoden

überschreiben müssen

Extract Composite

GrundprinzipDie Unterklassen in einer Hierarchie implementieren das selbe Composite Design Pattern.

Extrahiere eine Basisklasse, welche das Composite Design Pattern implementiert und leite die Unterklassen von dieser neuen Klasse ab.

Extract Composite

GrundideeDieses Refactoring ist sehr ähnlich dem Extract Superclass Refactoring von Fowler. Die gemeinsame Eigenschaft der Unterklassen ist in diesem Fall das Composite DP.

Unterklassen in einer Hierarchie speichern häufig Referenzen auf andere Objekte in Collections und bieten verschiedene Methoden für deren Manipulation an.Wenn die gespeicherten Objekte, wiederum der selben Hierarchie angehören, kann meistens mehrfach vorhandenes Code durch das Anwenden von Composite DP beseitigt werden.

Extract Composite

Extract Composite

public class LinkTag extends Node { ... private Vector<Node> children = new ... public void addChild(Node child) { ... } public boolean hasChild(Node child) {...} ... public String toTextString (){ String text = “”; for (Node child : children) text += child.toTextString(); return text; } ...}

Extract Composite

Extract Composite

public class CompositeNode extends Node { ... private Vector<Node> children = new ... public void addChild(Node child) { ... } public boolean hasChild(Node child) {...} ... public String toTextString (){ String text = “”; for (Node child : children) text += child.toTextString(); return text; } ...}

public class LinkTag extends CompositeNode { …

Extract Composite

Prozedur1. Erstelle eine neue Klasse, welche im Züge dieser Refactoring die

Implementierung des Composite Design Patterns wird.2. Leite alle Child-Container Unterklassen von dieser neuen Klasse ab.3. In den Unterklassen finde alle identischen oder ähnlichen Methoden zur

Behandlung von Kindern. Wenn nötig wende Rename Methode an, um gleiche Signatur in allen Unterklassen herzustellen.

4. Wende in den Unterklassen Pull Up Field an, um das Container Feld in die Basisklasse zu verlagern. Wende dann Pull Up Method an, um die identischen Methoden in die Basisklasse zu ziehen.

5. Wende überall, wo es möglich ist, Substitute Algorithm an, um die nicht identischen Methoden, welche nur teilweise den gleichen Code besitzen zu identischen Methoden umzwanderen und wiederhole Shritt 4. Wenn dies nicht möglich sein sollte verwende Form Template Method an.

Extract Composite

Vorteile•Beseitigt mehrfach vorhandenes Code für die Behandlung von

Speichern und der Manipulation von Kindern in den Unterklassen

•Verdeutlicht die Tatsache, dass die Behandlung von Kinderen in

zukunftigen Unterklassen ebenfalls geerbt werden kann

Replace One/Many Distinctions with Composite

GrundprinzipIn einer Klasse existieren unterschiedliche Methoden (oder Code-Stücke) für die Durchführung der gleichen Aufgabe an einem Objekt oder an einer Sammlung (Collection) von dem selben Objekt.

Verwende eine Composite Klasse, um die Behandlung von einem Objekt und einer Sammlung des selben Objekts zu vereinheitlichen.


GrundideeVereinheitliche die Bearbeitung von Single oder Collection Objekten und damit den Code des Servers sowie des Clienten.

Keine Unterscheidung zwischen ein oder mehreren Objekten Entfernung des duplizierten Codes in vielen Stellen.


public class Markler { ... public void verkaufeEigentum(WohnEinheit eigentum, String kaeufer){ eigentum.setBesitzer(Kaeufer); einkunft += eigentum.getPreis()*0.1; } ...

public void verkaufeEigentuemer(Vektor<WohnEinheit> eigentuemer, String kaeufer){ for (WohnEinheit eigentum : eigentuemer) { eigentum.setBesitzer(Kaeufer); einkunft += eigentum.getPreis()*0.1; } }

...}


public class WohnKomplex { public WohnKomplex(Vector<Wohneinheit> ws){ einheiten = ws; } public Vector<WohnEinheit> getWohnEinheiten(){ return einheiten; }

public void setBesitzer(String kaeufer){ for (WohnEinheit eigentum : einheiten) eigentum.setBesitzer(Kaeufer); }

public int getPreise(String kaeufer){ int preis = 0; for (WohnEinheit eigentum : einheiten) preis += eigentum.getPreis(); return preis; }

private Vector<WohEinheit> einheiten;}


public class Markler { ... public void verkaufeEigentum(WohnEinheit eigentum, String kaeufer){ eigentum.setBesitzer(Kaeufer); einkunft += eigentum.getPreis()*0.1; } ...}


Prozedur1. Erzeuge eine neue Klasse, welche im Züge dies Refactorings zur

Implementierung des Composite Design Patterns wird. Diese Klasse bekommt ein Collection als Argument seines Constructors und stellt die entsprechende get Methode zur Verfügung.

2. Erzeuge eine neue Instanz dieser Klasse in der Client-Klasse, in der Methode, die das Collection als Argument hat und überarbeite den Code, so dass nun diese Composite-Klasse anstelle von Collection verwendet wird.

3. Wende Extract Method an, um den Collection Handling Code in eine neue public Methode zu ziehen.

4. Benutze Move Method, um diese Methode in die Composite Klasse zu verlagern.

5. Ändere die Methode, welche die Sammlung von Objekten behandelte, so, dass sie nun aus einer einzigen Zeile besteht, welche die Single Object Methode aufruft und ihr als Argument das neue Composite Objekt übergibt.

6. Wende Inline Method an.7. Wende Encapsulate Collection in der Composite Klasse an: erstellt eine add(..)

Methode und verändert die get Methode so, dass nun eine unveränderliche Collection zurück gegeben wird


Vorteile•Beseitigt mehrfach vorhandenen Code für die Behandlung von einem

oder mehreren Objekten.•Vereinheitlicht den Zugriff der Client-Klassen: Eine Client-Klasse benutzt die selbe Methode, unabhängig davon ob sie ein oder eine Sammlung von dem selben Objekt als Argument benutzen will.•Unterstützt einen besseren Umgang mit Collection Objekten: Die Klienten können durch den Aufruf einer einzigen Methode das Ergebnis der Bearbeitung von einem Objekt-Baum zurück erhalten.

NachteilTypüberprüfung zur Laufzeit ist bei der Erstellung vom Composit

Objekt notwendig Erhöhtes Risiko zur Laufzeit (Generics)

Replace Hard-Coded Notifications with Observer

GrundprinzipDie Unterklassen sind hard-codiert, um beim Auftretten eines bestimmten Ereignisses eine einzige Instanz einer anderen Klasse zu benachrichtigen.

Beseitige die Unterklassen, indem die Basisklasse so erweitert wird, dass sie eine oder mehrere Instanzen jeder Klasse benachrichtigt kann, welche eine bestimmte Observer Interface implementiert.


GrundideeVerwende das Observer Design Pattern: Erstelle ein Observer Interface und erweitere die Basisklasse zu einer Subjekt-Klasse und die zu benachrichtigenden Klassen zu den Observer-Klassen.


Prozedur1. Falls eine der Notifier Unterklassen zusätzlich zu der

Benachrichtigungsaufgabe noch weitere receiver-speziefische Bearbeitungen durchführt, verlagere diese Arbeit in die Receiver Klasse durch die Anwendung von Move Method.

2. Erstelle ein Observer Interface, durch Anwendung von Extract Interface an einer der Receiver-Klassen.

3. Lass jede Receiver-Klasse das neu erzeugte Observer Interface implementieren. Ändere alle Notifier Unterklassen, so dass sie nur durch das Observer Interface mit ihren Receivern kommunizieren.

4. Wende Pull Up Method an allen Notifier Unterklassen, um die Notification-Methoden nach oben in die Basisklasse zu ziehen. Die Basis-Klasse ist nun eine Subjekt-Klasse.

5. Ergänze die Basisklasse mit Methoden für die Registrierung von Observern.

6. Überarbeite alle Observer, damit sie sich bei der Basis-Klasse (Subjekt) registrieren und nur mit ihr kommunizieren.


Vorteile•Lose Koppelung zwischen der Subject- und der Observer-Klasse.

•Unterstützt einen oder mehreren Observern.

Nachteile• Führt zu einer komplizierteren Design, besonders beim Cascading

Notifications.

• Es kann zu Speicherplatzproblemen führen, falls die Referenzen der

Observer von der Subjekt-Klasse nicht gelöscht werden.

Unify Interfaces with Adapter

GrundprinzipDie Client-Klasse interagiert mit zwei verschiedenen Server-Klassen,

mit unterschiedlichen Schnittstellen.

Vereinheitliche die Klient-Server-Schnittstelle mit Hilfe eines Adapters.


GrundideeDieses Refactoring ist im Grunde die Anwendung des Adapter [DP] und kann immer angewendet werden wenn:•Zwei Klassen das gleiche tun aber dafür unterschiedliche Schnittstellen anbieten.•Der Code in der Client-Klasse kann durch die Vereinheitlichung wesentlich vereinfacht werden•Die Schnittstelle einer beiden Klassen kann nicht einfach an die andere angepasst werden (Bibliotheken, Frameworks,…)

Die Grundidee ist gleiche die unterschiede in den Schnittstellen durch einen Adapter.


Prozedur1. Extract Interface in der Klasse anwenden, deren Schnittstelle von der Client-

Klasse bevorzugt wird. Dadurch wird die gemeinsame Schnittstelle erzeugt. 2. Überarbeite die ursprugliche Klasse und ersetze alle Referenzen in deren

Methoden auf die Klasse selbst durch das neu erzeugtes Interface.3. In der Client-Klasse Extract Class anwenden, um einen primitiven Adapter für die

zweite Server-Klasse zu erstellen.4. Die Client-Klasse so überarbeiten, dass überall anstelle von der zu

adaptierenden Klasse der Adapter verwendet wird.5. In der Client-Klasse Extract Method überall dort anwenden, wo der Client die

selbe Adaptee Methode anwendet, um eine Adaptee Aufruf-Methode zu erzeugen.

6. Alle diese Adaptee Aufruf-Methoden mit Move Method, in den Adapter verlagern.7. Die Adapter-Klasse muss nun das im Schritt 1 erzeugte Interface

implementieren.8. Überarbeite die Client-Klasse, so dass sie nur noch das Interface als einheitliche

Schnitte verwendet.


Vorteile•Beseitigung von mehrfach vorhandenen Code durch

Vereinheitlichung der Kommunikation zwischen der Client- und

verschiedenen Server-Klassen durch das gleiche Interface.

•Vereinfachung des Codes in der Client-Klasse.

Nachteile• Führt zu einer unnötig komplizierteren Design, wenn die

Schnittstellen der Serverklassen direkt angepasst werden können.

Extract Adapter

GrundprinzipEine Klasse ist Adapter für mehre unterschiedliche Versionen einer klassen, eines Komponenten, eines API oder eines anderen Entity.

Extrahiere einen Adapter für jede einzelne Version.

Extract Adapter

GrundideeHäufig muss eine Software mehrere Versionen eines Komponenten, einer Bibliothek oder API unterstutzen. Der Code, welche diese Aufgabe übernimmt muss nicht zwangsweise alle unterschiede an eine Stelle beweltigen.

Die Grundidee dabei ist: Erstelle für jede Version jeweils eine neue Adapterklasse zur Verfügung.

Extract Adapter

Extract Adapter

ProzedurFalls die jeweils richtige Methoden in der ursprünglichen Adapter Klasse

durch vielen Fallunterscheidungen gewählt werden, können die eigenständigen Adapter-Klasse für die jeweilige Version durch die Anwendung von Replace Conditional with Polymorphism erstellt werden.

Sollte dies nicht der Fall sein und die Adapter-Klasse version-spezifische Variablen und Methodenargumente unterstützen, müssen folgende Schritte durchgeführt werden:

1. Wende Extract SubClass oder Extract Class in der Adapter-Klasse an, um eine neue Adapter-klasse für jede spezifische Version zu erstellen.

2. Wende Move Method und Move Field an, um die entsprechend Felder und Methoden in die jeweilige neue Adapter-Klasse zu verlagern.

3. Beseitige dublikaten Code in den neuen Adapter-Klassen mittels Pull Up Method und Form Template Method.

Extract Adapter

Vorteile•Isoliert die Unterschiede in verschiedenen Versionen des benutzten

Komponenten

•Deutliche Verantwortungsaufteilung zwischen den Klassen, die

jeweils nur für eine einzige Version zuständig sind.

•Vermeidet sich häufig verändernden Code.

Nachteile• Kann eine wichtige Funktionalität vor der Client-Klasse verbergen,

wenn diese Funktionalität in der gerade angewandten Adapter nicht

vorhanden ist.

Replace implicit Language with interpreter

GrundprinzipZahlreiche Methoden in einer Klasse kombinieren Elemente einer

spezifischer Sprache.

Definiere neue Klassen für die jeweiligen Elemente dieser spezifischen Sprache, so dass diese Elemente zu interpretierbare Ausdrucke

kombiniert werden können.


GrundideeIn einer Klasse existieren zahlreiche Versionen einer Methode für die Ausführung einer bestimmten Aufgabe, welche sich darin unterscheiden, dass sie verschiedene Kombinationen einer Gruppe von Elementen als Argumentenliste haben.

Grundidee ist die Definition einer interpretierbare Sprache, deren Elemente als gültige Ausdrucke ausgewertet werden können, um beliebige Kombinationen zu verwirklichen.


Vorteile•Unterstützt die Kombination von Sprachelementen besser als eine

implizierte Sprache.

•Kein neuer Code wird benötigt, um neue Kombinationen zu bearbeiten.

•Erlaubt die Umstellung der Konfiguration zur Laufzeit.

Nachteile• Relative hoher Aufwand am Anfang, um neue Sprachelemente und die

dazugehörige Grammatik zu implementieren und die Client-Klassen

dementsprechend anzupassen.

• Sehr langes Programmieren bei besonders komplexen Sprachen.

•Unnötige Komplikation des Designs, wenn die spezifische Sprache zu

einfach ist.

Refactoring To Patterns Generalization Patterns. Einführung Ziel spezifisches Code ->...

Documents

Transcript of Refactoring To Patterns Generalization Patterns. Einführung Ziel spezifisches Code ->...