Advanced Refactoring Patterns

Refactoring bezeichnet in der Software-Entwicklung die manuelle oder
automatisierte Strukturverbesserung von Quelltexten unter Beibehaltung des
beobachtbaren Programmverhaltens.
Dabei sollen die Lesbarkeit, Verständlichkeit, Wartbarkeit und Erweiterbarkeit
verbessert werden, mit dem Ziel, den jeweiligen Aufwand für Fehleranalyse und
funktionale Erweiterungen deutlich zu senken.
Quelle: https://de.wikipedia.org/wiki/Refactoring

…is a disciplined technique for restructuring an existing body of
code, altering its internal structure without changing its external
behavior.
Its heart is a series of small behavior preserving transformations.
Each transformation (called a “refactoring”) does little, but a
sequence of transformations can produce a significant
restructuring. Since each refactoring is small, it’s less likely to go
wrong. The system is kept fully working after each small
refactoring, reducing the chances that a system can get seriously
broken during the restructuring.
refactoring.com

Add Parameter Introduce Class Annotation Replace Conditional with Polymorphism
Change Bidirectional Association to Unidirectional Introduce Expression Builder Replace Constructor with Factory Method
Change Reference to Value Introduce Foreign Method Replace Data Value with Object
Change Unidirectional Association to Bidirectional Introduce Gateway Replace Delegation With Hierarchy
Change Value to Reference Introduce Local Extension Replace Delegation with Inheritance
Collapse Hierarchy Introduce Named Parameter Replace Dynamic Receptor with Dynamic Method Definition
Consolidate Conditional Expression Introduce Null Object Replace Error Code with Exception
Consolidate Duplicate Conditional Fragments Introduce Parameter Object Replace Exception with Test
Decompose Conditional Isolate Dynamic Receptor Replace Hash with Object
Duplicate Observed Data Lazily Initialized Attribute Replace Inheritance with Delegation
Dynamic Method Definition Move Eval from Runtime to Parse Time Replace Loop with Collection Closure Method
Eagerly Initialized Attribute Move Field Replace Magic Number with Symbolic Constant
Encapsulate Collection Move Method Replace Method with Method Object
Encapsulate Downcast Parameterize Method Replace Nested Conditional with Guard Clauses
Encapsulate Field Preserve Whole Object Replace Parameter with Explicit Methods
Extract Class Pull Up Constructor Body Replace Parameter with Method
Extract Interface Pull Up Field Replace Record with Data Class
Extract Method Pull Up Method Replace Subclass with Fields
Extract Module Push Down Field Replace Temp with Chain
Extract Subclass Push Down Method Replace Temp with Query
Extract Superclass Recompose Conditional Replace Type Code with Class
Extract Surrounding Method Remove Assignments to Parameters Replace Type Code with Module Extension
Extract Variable Remove Control Flag Replace Type Code With Polymorphism
Form Template Method Remove Middle Man Replace Type Code with State/Strategy
Hide Delegate Remove Named Parameter Replace Type Code with Subclasses
Hide Method Remove Parameter Self Encapsulate Field
Inline Class Remove Setting Method Separate Query from Modifier
Inline Method Remove Unused Default Parameter Split Temporary Variable
Inline Module Rename Method Substitute Algorithm
Inline Temp Replace Abstract Superclass with Module
Introduce Assertion Replace Array with Object
refactoring.com

“Code without tests is bad code. It doesn't matter
how well written it is; it doesn't matter how pretty
or object-oriented or well-encapsulated it is. With
tests, we can change the behavior of our code
quickly and verifiably. Without them, we really
don't know if our code is getting better or worse.”

1. Quellcode einchecken.
2. Einen Überblick darüber verschaffen was geändert werden soll.
3. Mindestens einen Test schreiben der das bestehende Verhalten
charakterisiert.
4. Refaktorisieren
5. Prüfen ob sich das Verhalten verändert hat.

Situationen
„Ich weiß nicht was mein Code macht, soll diesen Zustand aber ändern.“
Vorgehen
Wir schreiben einen Test ohne Asserts und sehen uns anhand der
Codeabdeckung an was passiert.

Situationen
„Ich will das mein Code sich nach den Änderungen so verhält wie vorher.“
Vorgehen
Man schreibt oder generiert einen oder mehrere Tests um das Verhalten zu
prüfen.

Situationen
„Ich muss Interna einer Klasse manipulieren um etwas testen zu können, will
dies aber nur für die Tests tun.“

Situationen
„Wir haben keine Zeit für umfassende Refactorings.“
„Ich möchte Code testgetrieben in einer untestbaren Umgebung umsetzen.“
„Ich kann das Problem durch reines Hinzufügen von Code lösen.“

Situationen
„Ich muss eine vorhandene Schnittstelle ändern, möchte das Verhalten aber
nicht unvorhergesehen schädigen.“

Situationen
„Ich habe eine Klasse/Methode die viel zu komplex ist.“
Vorgehen
Wir lagern komplexe Methoden in eigene Klassen aus und brechen sie dort in
weitere Methoden auf.

Situationen
„Ich muss ein altes System ablösen, es ist aber so komplex, dass ich dies nicht
mit einen Mal tun kann. “
Vorgehen
Wir bauen das neue System als Sprouts, ziehen schrittweise die Funktionalität
aus dem alten und entfernen all die Teile die nicht mehr im alten gebraucht
werden.

Quelle: https://martinfowler.com/bliki/RefactoringMalapropism.html
Refactoring
• Kleine lokale Änderungen.
• Schnelle Anpassungen mit geringen Auswirkungen auf
andere.
• Können ohne größere Absprache durchgeführt werden.
• Keine tiefgreifenden architekturellen Anpassungen in
bestehendem Code.
Restructuring
• Großflächige architekturelle Anpassungen die sich
auf die Gesamtapplikation auswirken können.
• Können andere Entwickler behindern.
• Sollten nicht ohne Absprache und Planung
durchgeführt werden.

Advanced Refactoring Patterns

Weitere ähnliche Inhalte

Mehr von Hendrik Lösch (20)

Advanced Refactoring Patterns

Hinweis der Redaktion