Durchsuchen Sie tutego:

Suchbegriffe Suchen

Sie befinden sich hier: Home » Ratgeber » Java » Refactoring

Refactoring

Die Seite sowie Unterseiten sind Übersetzungen der Refactoring-Liste von Martin Fowler.

Methoden zusammenstellen (Composing Methods)

• Methode extrahieren (Extract Method)
• Methode inline setzen (Inline Method)
• Temporäre Variable entfernen (Inline Temp)
• Ersetze temporäre Variable durch Anfragemethode (Replace Temp with Query)
• Beschreibende Variable einführen (Introduce Explaining Variable)
• Trenne temporäre Variable (Split Temporary Variable)
• Entferne Zuweisung an Parametervariable (Remove Assignments to Parameters)
• Ersetze eine Methode durch ein Methoden-Objekt (Replace Method with Method Object)
• Ersetze Algorithmus (Substitute Algorithm)

Eigenschaften zwischen Objekten verschieben (Moving Features Between Objects)

• Verschiebe Methode (Move Method)
• Verschiebe Attribut (Move Field)
• Extrahiere Klasse (Extract Class)
• Setze Klasse inline (Inline Class)
• Verstecke den Delegate (Hide Delegate)
• Entferne Klasse in der Mitte (Remove Middle Man)
• Führe fremde Methode ein (Introduce Foreign Method)
• Führe lokale Erweiterung ein (Introduce Local Extension)

Daten organisieren (Organizing Data)

• Kapsele eigene Attributzugriffe (Self Encapsulate Field)
• Ersetze eigenes Attribut durch Objektverweis (Replace Data Value with Object)
• Ersetzte Wert durch Referenz (Change Value to Reference)
• Ersetzte Verweis durch Wert (Change Reference to Value)
• Ersetze Feld durch ein Objekt (Replace Array with Object)
• Beobachtete Daten verdoppeln (Duplicate Observed Data)
• Unidirektionale Beziehung in bidirektionale Beziehung ändern (Change Unidirectional Association to Bidirectional)
• Bidirektionale Beziehung in unidirektionale Beziehung ändern (Change Bidirectional Association to Unidirectional)
• Ersetze magische Zahl durch symbolische Konstante (Replace Magic Number with Symbolic Constant)
• Kapsele Attribut (Encapsulate Field)
• Kapsele die Collection (Encapsulate Collection)
• Ersetze einen Datensatz durch eine Datenklasse (Replace Record with Data Class)
• Ersetze Typenschlüssel durch eine Klasse (Replace Type Code with Class)
• Ersetzte Typ-spezifischen Code durch Unterklassen (Replace Type Code with Subclasses)
• Ersetzte Typ-spezifischen Code durch Zustand/Strategie-Muster (Replace Type Code with State/Strategy)
• Ersetze Unterklassen durch Attribute (Replace Subclass with Fields)

Bedingte Ausdrücke vereinfachen (Simplifying Conditional Expressions)

• Zerlege Bedingung (Decompose Conditional)
• Bedingungen von Ausdrücken zusammenführen (Consolidate Conditional Expression)
• Wiederholte Anweisungen aus Bedingungen zusammenführen (Consolidate Duplicate Conditional Fragments)
• Kontroll-Flags entfernen (Remove Control Flag)
• Geschachtelte Bedingungen durch Wächter ersetzen (Replace Nested Conditional with Guard Clauses)
• Ersetze Fallunterscheidungen durch Polymorphie (Replace Conditional with Polymorphism)
• Null-Objekt einführen (Introduce Null Object)
• Assertions einführen (Introduce Assertion)

Methodenaufrufe vereinfachen (Making Method Calls Simpler)

• Benenne Methode um (Rename Method)
• Parameter hinzufügen (Add Parameter)
• Entferne Parameter (Remove Parameter)
• Trenne Anfrage vom Verändern (Separate Query from Modifier)
• Parametrisiere Methode (Parameterize Method)
• Ersetze Parameter durch explizite Methoden (Replace Parameter with Explicit Methods)
• Vorhandenes Objekt übergeben (Preserve Whole Object)
• Ersetze Parameter durch Methode (Replace Parameter with Method)
• Parameter-Objekt einführen (Introduce Parameter Object)
• Entferne Setter (Remove Setting Method)
• Verstecke eine Methode (Hide Method)
• Ersetze Konstruktor mir Fabrik-Methode (Replace Constructor with Factory Method)
• Explizite Typanpassung kapseln (Encapsulate Downcast)
• Ersetze Fehlercodes durch Ausnahmen (Replace Error Code with Exception)
• Vermeide Ausnahmen durch Tests (Replace Exception with Test)

Umgang mit Generalisierung (Dealing with Generalization)

• Attribut hochziehen (Pull Up Field)
• Methode hochziehen (Pull Up Method)
• Konstruktor-Köper hochziehen (Pull Up Constructor Body)
• Methode nach unten verlegen (Push Down Method)
• Attribut nach unten verlegen (Push Down Field)
• Extrahiere Unterklasse (Extract Subclass)
• Extrahiere Oberklasse (Extract Superclass)
• Extrahiere Schnittstelle (Extract Interface)
• Hierarchien abbauen (Collapse Hierarchy)
• Schreibe eine Schablonenmethode (Form Template Method)
• Ersetzte Vererbung durch Delegation (Replace Inheritance with Delegation)
• Ersetzte Delegation durch Vererbung (Replace Delegation with Inheritance)

Weiteres

• Konvertiere dynamische in statische Erzeugung (Convert Dynamic to Static Construction)
• Konvertiere statische in dynamische Erzeugung (Convert Static to Dynamic Construction)
• Extrahiere Paket (Extract Package)
• Führe Synchronizer Token ein (Introduce Synchronizer Token)
• Verschiebe Klasse (Move Class)
• Beschränke Gültigkeit der Variable (Reduce Scope of Variable)
• Entferne doppelte Verneinung (Remove Double Negative)
• Verbinde Definition und Initialisierung einer Variablen (Replace Assignment with Initialization)
• Ersetze Fallunterscheidungen durch Besucher-Muster (Replace Conditional with Visitor)
• Ersetzte Iteration durch Rekursion (Replace Iteration with Recursion)
• Ersetze Rekursion durch Iteration (Replace Recursion with Iteration)
• Ersetze statische Variable durch Parameter (Replace Static Variable with Parameter)
• Drehe Bedingung um (Reverse Conditional)
• Trenne Schleife (Split Loop)
• Konvertiere dynamische in statische Erzeugung (Convert Dynamic to Static Construction)
• Konvertiere statische in dynamische Erzeugung (Convert Static to Dynamic Construction)

Enterprise Java

• Eliminiere Kommunikation zwischen Entity-Beans (Eliminate Inter-Entity Bean Communication)
• Session-Beans zusammenführen (Merge Session Beans)
• Ummantele Entity-Beans durch Session-Beans (Wrap entities with session)
• Nutze einen Connection-Pool (Use a Connection Pool)
• Trenne Datenzugriffscode (Separate Data Access Code)
• Geschäftslogik in Session-Beans legen (Move Business Logic to Session)
• Verstecke Schichten-spezifische Details von der Business-Tier (Hide presentation tier-specific details from the business tier)
• Business-Delegate einführen (Introduce Business Delegate)
• Controller einführen (Introduce A Controller)
• Ungleiche Logik lokalisieren (Localize Disparate Logic)
• Refactoring einer Architektur durch Schichten (Refactor Architecture by Tiers)