Refaktorisierung

Buchholz, Stefan 25. April 2005

Ein Einblick in die Refaktorisierung

und dessen Unterstützung in der Entwicklungsumgebung Eclipse 3.0

Inhaltsverzeichnis

1 Motivation 2 1.1 Das Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Die Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Refaktorisierung 3 2.1 Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Methoden der Refaktorisierungen . . . . . . . . . . . . . . . . 3 2.3 Zeitpunkt einer Refaktorisierung . . . . . . . . . . . . . . . . 3 2.4 Methoden der Refaktorisierung . . . . . . . . . . . . . . . . . 4 2.5 Refatorisierungsunterstützung bei Entwicklungstools . . . . . 4

2.5.1 Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.5.2 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.5.3 .Net . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.5.4 C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.5.5 Visual Basic . . . . . . . . . . . . . . . . . . . . . . . . 6 2.5.6 Phyton . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.5.7 Self . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.5.8 Delphi . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Refaktorisierung in Eclipse 7 3.1 Refaktorisierungen in Eclipse . . . . . . . . . . . . . . . . . . 7 3.2 Beispiele in Eclipse . . . . . . . . . . . . . . . . . . . . . . . . 8

3.2.1 Umbenennen . . . . . . . . . . . . . . . . . . . . . . . 8 3.2.2 Methode extrahieren . . . . . . . . . . . . . . . . . . . 9 3.2.3 Methodensignatur ändern . . . . . . . . . . . . . . . . 11 3.2.4 Hochsetzen . . . . . . . . . . . . . . . . . . . . . . . . 12 3.2.5 Fabrikmethode extrahieren . . . . . . . . . . . . . . . 14 3.2.6 Schnittstelle extrahieren . . . . . . . . . . . . . . . . . 16

4 Zusammenfassung 18

Literatur 19

1 Motivation

1.1 Das Problem

In der Softwareentwicklung gibt es verschiedene Probleme. Eines der Probleme betrifft die Struktur von Softwaresystemen. Bei der Programmierung kommt es trotz guter Ingenieurtechnischer Planung zur ”Allmählige Verfertigung des Gedanken beim Schreiben“ (Cub05, S.181). Dieser Verfertigung führt dazu, dass die Struktur an manchen Stellen von der geplanten Struktur abweicht. Die Wartung und die Pflege von Softwaresystemen führt ebenfalls zu einer Verschlechterung des bestehenden Codes und dessen Struktur. Wie kann man solch einen ”Alterungsprozess“ (Sch03) rückgängig machen bzw. stoppen?

1.2 Die Lösung

Eine Lösung bietet die Refaktorisierung. Sie ermöglicht, mittels ausgewählten Methoden, bestimmte Strukturprobleme zu beseitigen. Martin Fowler hat auf einer Webseite (ref) einen Katalog mit allen derzeit bekannten Methoden gelistet. Das Problem jedoch bei der Refaktorisierung ist, dass umfangreiche Arbeiten am Code vorgenommen werden müsse. Diese Arbeiten sind im allgemeinen ”Copy & Paste - Arbeiten“. Da meist Funktionen geändert werden und diese an unterschiedlichen Stellen im Code aufgerufen werden, ist ein auffinden dieser Funktionsaufrufe recht umständlich. Es wäre von Vorteil, wenn die Entwicklungsumgebung, mit der man arbeitet, das Refaktorisieren unterstützt. Im Folgenden soll unter anderem diese Möglichkeiten am Beispiel von Eclipse betrachtet werden.

2 Refaktorisierung

Dieser Abschnitt soll sich mit der Refaktorisierung im speziellen beschäftigen. Es wird die Frage geklärt was eine Refaktorisierung ist und zu welchen Zeitpunkt diese am sinnvollsten ist. Des Weiteren sollen einige Methoden betrachtet werden und ein Blick auf die Softwaretools gewährt werden die eine Refaktorisierung unterstützen.

2.1 Definition

Der Begriff der Refaktorisierung wird oft missverstanden. Zumeist durch eine fehlerhafte Übersetzung aus dem Englischen. Aus diesem Grund hier eine Definition aus dem Standartwerk von Martin Fowler (Fow00).

Refaktorisierung (Substantiv): Eine Änderung an der internen Struktur einer Software, um sie leichter verständlich zu machen und einfacher zu verändern, ohne ihr beobachtbares Verhalten zu ändern. (Fow00)

Refaktorisieren (Verb): Eine Software um strukturieren, ohne ihr beobachtbares Verhalten zu ändern, indem man eine Reihe von Refaktorisierungen anwendet. (Fow00).

2.2 Methoden der Refaktorisierungen

An dieser Stelle müssten die einzelnen Refaktorisierungen benannt und erläutert werden. Jedoch würde dies den Umfang dieser Arbeit sprengen. Aus diesem Grund sei auf die verschieden Quellen (Fow00) (ref) verwiesen die diese Thematik ausführlich behandeln.

2.3 Zeitpunkt einer Refaktorisierung

Der Zeitpunkt einer Refaktorisierung sollte gut überlegt sein. In der Praxis haben sich die folgenden Situationen als richtiger Zeitpunkt für die Refaktorisierung bewährt und durchgesetzt:

• Bugs sollen gefixt werden,

• Erweiterungen bzw. funktionale Änderungen sollen vorgenommen werden,

• Applikationsteile sollen wieder verwendet werden oder

• ein Code-Review soll durchgeführt werden.

(Sch03)

Oliver Fischer liefert in seinem Artikel (Fis02) einen weiter Punkt der Beachtung finden sollte. Eine Refaktorisierung sollte nur dann durchgeführt werden, wenn genügend Zeit zur Verfügung steht, da die Rafaktorisierung keine neue Funktionalität mit sich bringt. Doch auch hier gibt es eine Ausnahme von der Regel:

”Hilft die geplante Änderung, das angestrebte Ziel schneller zu erreichen, sollte man refaktorisieren. …“ (Fis02)

2.4 Methoden der Refaktorisierung

Es gibt hunderte von Methoden zur Refaktorisierung. Eine eingehende Betrachtung der einzelnen Methoden würde den Rahmen dieses Vortrages sprengen. Weiter unten werden einige exemplarische Methoden im Zusammenhang mit dem Umgang der Entwicklungsumgebung Eclipse beschrieben. Des weiteren soll hier an dieser Stelle nochmals der Verweis auf die einschlägige Fachliteratur (Fow00) und das Internet (ref) hingewiesen werden.

2.5 Refatorisierungsunterstützung bei Entwicklungstools

Da einzelne die Refaktorisierungsmethoden zu einer umfangreichen Änderung im Code führen können, ist es wünschenswert, dass der Entwickler von der Entwicklungsumgebung unterstützt wird. Im folgenden ist eine Auflistung (ref) einiger Tools zu sehen. Die Tools sind nach Programmiersprache geordnet.

2.5.1 Smalltalk

Der ”Smalltalk Refactoring Browser“ ist das Original Refaktorisierungs-Tool und bietet den größten Funktionsumfang.

2.5.2 Java

IntelliJ Idea Dieses Tool geht über das normale refaktorisieren hinaus und ist sehr umfangreich.

Eclipse Diese OpenSource Entwicklungsumgebung bringt ein eigenständige Refaktorisierung mit und ist bereits integriert. Eclipse wird später näher betrachtet.

JFactor Mit diesem PlugIn arbeiten der JBuilder und Visual Age. Dieses Tool hat einen guten Funktionsumfang und schaut auf eine lange Geschichte in Smalltalk, Java-VM und Compilertechnologie zurück.

XRefactory Dieses PlugIn ist für emacs. Es bietet neben einer Codevervollständigung auch Refaktorisierung an.

Together-J Dieses Tool wurde vor kurzem von Borland gekauft und ist ein CASE-Tool mit UML-Fähigkeiten, welches auch Refaktorisierung unterstützt.

JBuilder Borland Tools bieten eine geringe Refaktorisierung an. Es gibt jedoch PlugIns die eine größer Funktionalität besitzen.

RefactorIt Dies ist ein PlugIn für die Entwicklungsumgebungen NetBeans, Forte, JDeveloper und JBuilder. Es kann auch einzeln benutzt werden.

JRefactory Dieses Plugin kann von JBuilder, NetBeans und Elixir genutzt werden. Diese Tool kann auch zum erstellen von UML-Diagrammen genutzt werden.

Transmogrify und JafaRefactor Das sind Plugins für jEdit.

2.5.3 .Net

ReSharper Dieses Tool ähnelt dem IntelliJ aus der Java-Welt. Es besitzt viele Funktionen des IntelliJ-Tools. Es wird bei vielen Entwicklern geschätzt.

C# Refactory Dises Tool ist vollständig in das Visual Studio .net integriert und erweitert diese Entwicklungsumgebung mit Refaktorisierungsmöglichkeiten.

C# Refactoring Tool

2.5.4 C/C++

SlickEdit

Ref++ Dieses AddIn erweitert das Visual Studio um die Möglichkeit bei C++ Refaktorisierung vorzunehmen.

Xrefactory Dies ist ein weiteres PlugIn für emacs. Es unterstützt die Refaktorisierungen Umbenennen, Parameteränderung und Methode extrahieren.

2.5.5 Visual Basic

Aivosto Project Analyzer Dieses Tool ist kein eigentliches Rafaktorisierungstool sondern mehr ein Codeoptimierer. Es unterstützt kapseln von Feldern, entfernen von Parametern und versteckt Methoden.

2.5.6 Phyton

Bicycle Repair Man

2.5.7 Self

Guru

Guru findet gemeinsame Teilausdrücke von Methoden, extrahiert diese und ersetzt die Ausdrücke in den ursprünglichen Methoden durch einen Aufruf der neuen Methode. Die Namen der neuen Methoden werden generiert. (Har04)

2.5.8 Delphi

Model Maker ModelMaker ist ein UML Modellierungs- und Refactoring-Tool, welches in die Delphi-IDE integriert werden kann. Dieses Tool unterstützt nicht alle Rafaktorisierungen. Zum Beispiel wird ”Methoden extrahieren“ nicht unterstützt.

3 Refaktorisierung in Eclipse

3.1 Refaktorisierungen in Eclipse

Eclipse unterstützt den Entwickler bei seinem Vorhaben Software zu verbessern. Dazu stellt es eine Reihe von Refaktorisierungen zur Verfügung:

• Umbenennen

• Versetzen

• Methodensignatur ändern

• Anonyme Klasse in verschachtelte konvertieren

• Verschachtelten Typ in höchste Ebene konvertieren

• Herabsetzen

• Hochsetzen

• Schnittstelle extrahieren

• Nach Möglichkeit Supertyp verwenden

• Integrieren

• Methode extrahieren

• Lokale Variable extrahieren

• Konstante extrahieren

• Lokale Variable in Feld konvertieren

• Feld kapseln

• Fabrikmethode extrahieren (ecl)

Zu sehen ist, dass Eclipse nicht bzw. nur teilweise alle Refaktorisierungen beherrscht. Somit sind Nacharbeiten oder gar ganze Refaktorisierungen manuell notwendig. Die Möglichkeiten der Umstrukturierung in Eclipse sind trotzdem umfangreich, so dass der Entwickler entlastet wird und kostbare Zeit einspart. Im nächsten Abschnitt werden einige Refaktorisierungen exemplarisch vorgestellt.

3.2 Beispiele in Eclipse

3.2.1 Umbenennen

Motivation Die Refakorisierung ”Umbenennen“ wird meist angewendet, um nicht eindeutig gewählte Namen zu ändern. Im Beispiel gibt es in der

Klasse Rename Methode eine Methode getPersonTelefonNumber. Bei

genauerer Betrachtung fällt auf, dass eine Büronummer übergeben wird. Programmiert ein Entwickler an der Client Klasse so kann es zu Missverständnissen führen. Es ist also eine Umbenennung der Methode zu empfehlen.

Beispiel:

public class Client

{

       Rename Methode  person;
       public String getPersonTelefonNumber(){
              return  person.getTelefonNumber();

} }

public class Rename Methode

{

       int  officeNumber;
       int  officeAreaCode;
       public String getTelefonNumber(){
              return "("+  officeAreaCode + ") "+  officeNumber;

} }

Es ist eine Refaktorisierung vorzunehmen. Dabei markiert man in Eclipse den zu ändernden Namen. In unserm Falle ist es getTelefonNumber, in der Klasse Rename Methode. Dann nutzt man, mittels rechter Maustaste, das Menü und wählt dort Refactoring und dann Umbenennen... aus. Man hat nun die Möglichkeit dort einen passenderen Namen zu wählen. Wir nehmen getOfficeTelefonNumber. Eclipse ersetzt, wie wir sehen nicht nur den Methodennamen in der Klasse Rename Methode, sondern auch alle Verweise in der Klasse Client. Voraussetzung ist, dass man in Eclipse immer in den Dialogen ”Verweis aktualisieren“ aktiviert wird. Dies sollte auch in den kommenden Refaktorisierungen der Fall sein.

Nach Refaktorisierung mit Eclipse:

public class Rename Methode {
       int  officeNumber;
       int  officeAreaCode;
       public String getOfficeTelefonNumber(){
              return "("+  officeAreaCode + ") "+  officeNumber;

} }

public class Client {
       Rename Methode  person;
       public String getPersonTelefonNumber(){
              return  person.getOfficeTelefonNumber();

} }

3.2.2 Methode extrahieren

Motivation Diese Refaktorisierung wird dann angewendete, wenn Methoden zu lang bzw. doppelter Code vorkommt. Lange Methoden sind anfällig für Fehler und schwer zu warten. Außerdem lassen sich Teile aus ihnen nicht wieder verwenden. Doppelter Code ”riecht“ förmlich nach Fehlern in der Struktur. Aus dem doppelten Code sollten auch neue Methoden extrahiert werden. In unserm Beispiel gibt es eine lange Methode. Eclipse unterstützt die Refaktorisierung sehr gut.

Beispiel:

void printOwing(){
       Enumeration e =  orders.elements();
       double outstanding = 0.0;
       //print banner
       System.out.println("****************************");
       System.out.println("******Custom Owes **********");
       System.out.println("****************************");

       //calculate outstanding
       while(e.hasMoreElements()){
              Order each = (Order) e.nextElement();
              outstanding += each.getAmount();

}

       //print details
       System.out.println("name: "+  name);
       System.out.println(ämount: "+ outstanding);

}

Wir wollen die Methode printOwing aufteilen. In drei kleinere Methoden, da wir diese Teile wieder verwenden wollen. Das einfachste extrahieren einer Methode ist das ohne Variablen. Wir möchten eine Methode printBanner. Dazu markieren wir die entsprechenden Codezeilen und führen in Eclipse eine entsprechende Refaktorisierung durch. Eclipse ersetzt den Codeteil, der nun in der neuen Methode steht, durch einen Aufruf. Das selbe passiert auch mit Codeteilen die eine lokale Variable übergeben bekommen müssen (printDetail) bzw. einen Parameter zurückbekommen

(calculate).

Nach Refaktorisierung mit Eclipse:

private Vector  orders;
private String  name;
void printOwing(){
       Enumeration e =  orders.elements();
       double outstanding = 0.0;
       printBanner();
       outstanding = calculate(e, outstanding);
       printDetails(outstanding);

}

private double calculate(Enumeration enum, double out) {
       //calculate outstanding
       while(enum.hasMoreElements()){
              Order each = (Order) enum.nextElement();
              out += each.getAmount();

}

       return out;

}

private void printDetails(double outstanding) {
       //print details
       System.out.println("name: "+  name);
       System.out.println(ämount: "+ outstanding);

}

private void printBanner() {
       //print banner
       System.out.println("****************************");
       System.out.println("******Custom Owes **********");
       System.out.println("****************************");

}

3.2.3 Methodensignatur ändern

Motivation Eines der meist gebrauchten Refaktorisierungen ist das ändern der Methodensignaturen. Es werden Parameter hinzugenommen und entfernt. Eclipse unterstützt den Vorgang in zweifacher Hinsicht. Zum einem kann man die Signatur direkt ändern und zum anderem kann einer bisherigen Konstante in eine Variable umgeschrieben werden. Die folgenden Beispiele zeigen beide Vorgänge. Die Methode ist bewusst einfach gehalten.

Beispiel:

public void aufruf(){
       System.out.println(Aktion());

}

public int Aktion(){
       int wert;
       wert = 5 + 3;
       return wert;

}

Als erstes wollen wir die Methoden Signatur ändern. Hierzu wird die Methodendefiniton markiert und dann im die Refaktorisierung ”Methodensignatur ändern...“ ausgewählt. Im folgenden Menü können Parameter mit ihren Typen und Variablennamen hinzugefügt bzw. entfernt werden. Zu beachten ist, das immer ein Standartwert angegeben werden muss. Dieser Standardwert wird in die Verweise eingesetzt, die bisher auf diese Methode aufrufen. Das Beispiel zeigt eine solche Änderung. Zu sehen ist jedoch, dass eine manuelle Änderung noch vorzunehmen ist. Nach Refaktorisierung mit Eclipse:

public void aufruf(){
       System.out.println(Aktion(3));

}

public int Aktion(int i){
       int wert;
       wert = 5 + 3;
       return wert;

}

Um eine bestimmte Konstante zu ändern, in unserm Fall wollen wir die 3 in einen Parameter umwandeln, markieren wir die 3. Danach wählen wir die Rafaktorisierung ”Parameter einführen“. Nach Abschluss der Refaktorisierung hat Eclipse die Konstante durch einen Variable ersetzt und die Verweise entsprechend aktualisiert.

Nach Refaktorisierung mit Eclipse:

public void aufruf(){
       System.out.println(Aktion(3));

}

public int Aktion(int i){
       int wert;
       wert = 5 + i;
       return wert;

}

3.2.4 Hochsetzen

Die Abbildung 1 veranschaulicht das Hochsetzen. Ausgangspunkt ist ein Fehler in der Struktur. Zwei Unterklassen besitzen zwei gleiche Funktionen die denselben Zweck erfüllen. Hier ist es die Methode getName. Es wäre also Sinnvoll diese Funktion in die Vaterklasse zu verlegen. Eclipse ermöglicht dies mit der Refaktorisierung ”Hochsetzen“.

Beispiel:

public class Employee {}
public class Salesman extends Employee {
       String  name;
       String getName(){
              return  name;

} }

public class Engineer extends Employee {
       String  name;
       String getName(){
              return  name;

} }

Nach Refaktorisierung mit Eclipse: Die Besonderheit die uns Eclipse hier bietet ist, dass nach dem markieren der Funktion und der Auswahl der Refaktorisierung ”Hochsetzen“ ein Dialog erscheint, der es mir ermöglicht gleichzeitig bestimmte Variablen hoch zusetzen. Nach Auswahl der Methode und der Variablen zeigt mir Eclipse gleichnamige Funktionen und Variablen in Subklassen. So ist das auffinden aller Methoden möglich, die hoch gesetzt werden können. Folgender Code zeigt das Ergebniss.

public class Employee {
       String  name;
       protected String getName() {
              return  name;

}

}

public class Engineer extends Employee {}
public class Salesman extends Employee {}

3.2.5 Fabrikmethode extrahieren

Motivation Wenn es in einer Klasse Variablen gibt die den Typ widerspiegeln, sollte man es sich überlegen, die Typschlüssel durch Unterklassen zu ersetzen. Die genaue Unterklasse hängt von Typschlüssel ab. Da ein Konstruktor jedoch nur ein Objekt zurück liefern kann ist eine Fabrikmethode notwendig. Die Funktionsweise und Eigenschaften der Fabrikmethode sollen hier nicht diskutiert werden. Ein Verweis auf die einschlägige Fachliteratur (GHJV96) soll hier genügen. Soviel soll aber gesagt werden. Der eigentliche Konstruktor wird private und eine neue Methode create... soll den Konstruktor aufrufen.

Beispiel:

public class Client {
       public Client() {
              Employee eng = new Employee(Employee.ENGINEER);

} }

public class Employee {
       private int  type;
       static final int ENGINEER = 0;
       static final int SALESMAN = 1;
       static final int MANAGER = 2;
       public Employee(int type){
              type = type;

} }

Wie zu sehen ist besitzt die Klasse Employee drei Typschlüssel. Des weiteren wird der Konstruktor in der Klasse Client und erwartet einen ENGINEER als Typ. Nun möchten wir eine Fabrikmethode erstellen um Unterklassen erstellen zu können. Zu beachten ist hier, dass wir eigentlich in unserem Vorhaben eigentlich zwei Refaktorisierungen ausführen müssten. Als erstes wäre die Refaktorisierung ”Konstuktor durch Fabrikmethode ersetzen“ nötig und danach ”Typschlüssel durch Unterklassen ersetzen“. Hier weißt Eclipse seine Grenzen auf. Es unterstützt uns nur bei der Refaktorisierung ”Konstuktor durch Fabrikmethode ersetzen“. Der zweite Schritt muss vom Entwickler selbst ausgeführt werden.

Um die Refaktorisierung durch zuführen klickt man auf den entsprechenden Konstruktor und wählt die Refaktorisierung ”Factory einführen...“. Wichtig hierbei ist, dass der Konstruktor als private deklariert werden soll. Eclipse gibt einen Namen vor, der selbstverständlich an unsere Bedürfnisse angepasst werden kann. Nach der Refaktorisierung sind die entsprechenden Änderungen vorgenommen wurden und die Verweise aktualisiert, wie der folgende Code zeigt.

Nach Refaktorisierung mit Eclipse:

public class Employee {
       private int  type;
       static final int ENGINEER = 0;
       static final int SALESMAN = 1;
       static final int MANAGER = 2;
       public static Employee createEmployee(int type) {
              return new Employee(type);

}

       private Employee(int type){
              type = type;

} }

public class Client {
       public Client() {
              Employee eng = Employee.createEmployee(Employee.ENGINEER);

} } 3.2.6 Schnittstelle extrahieren

Motivation Es gibt Klassen und Funktionen die nur einen bestimmten Teil eines Objektes nutzen. Warum also diesen Klassen und Funktionen die ganze Funktionsvielfalt des Objektes zur Verfügung stellen? Es reicht doch aus, die Schnittmenge der Funktionen zur Verfügung zu stellen. Dieses bereitstellen erreicht man mittels einer Schnittstelle. Die Methode charge nutzt zum Beispiel nur zwei Methoden der Klasse Employee.

Beispiel:

double charge(Employee emp, int days){
       int base = emp.getRate() * days;
       if(emp.hasSpecialSkill()){
              return base * 1.05;

}

       else return base;

}

public class Employee{
       public int getRate(){
              return 0;

}

       public boolean hasSpecialSkill(){
              return true;

}

       public String getName(){
              return "Mustermann";

}

       public String getDepartment(){
              return Ïrgendwas";

} }

Eclipse ermöglicht uns mittels der Refaktorisierung ”Schnittstelle extrahieren...“ das geplante Vorgehen. Dafür klickt man in die Klasse, die dann das Interface implementieren soll und wählt die eben genannte Refaktorisierung. Eclipse listet nun alle Methoden auf, die in dem Interface stehen können (Im Beispiel sind es die Methoden getRate und hasSpecialSkill die wir nun auswählen). Wichtig ist, in diesem Feld, das Häkchen bei Verweise zu machen. Man wählt nun noch einen entsprechenden Interfacenamen und erhält unten stehendes Ergebnis.

Nach Refaktorisierung mit Eclipse:

public interface Billable{
public abstract int getRate();
public abstract boolean hasSpecialSkill();

}

public class Employee implements Billable{
public int getRate(){
       return 0;

}

public boolean hasSpecialSkill(){
       return true;

}

public String getName(){
       return "Mustermann";

}

public String getDepartment(){
       return Ïrgendwas";

} }

double charge(Billable emp, int days){
int base = emp.getRate() * days;
if(emp.hasSpecialSkill()){
       return base * 1.05;

}

else return base;

}

4 Zusammenfassung

Refaktorisierung ist eine sehr gute Möglichkeit in einen chaotischen Code wieder Struktur zu bringen. Mit einem ordentlichen Refoktorisierungstool oder einer Entwicklungsumgebung die Refaktorisierung unterstützt kann der Entwickler eine Menge Zeit und somit auch Kosten einsparen. Jedoch nehmen die Tools, dem Entwickler, nicht alle Refaktorisierungen ab. Trotzdem ist solch ein Tool zu empfehlen, da es einem wie gesagt eine Menge Arbeit abnimmt.

Literatur

[Cub05] Ulrich Cuber. Einstieg in Eclipse 3. Galileo Computing, 2005. [ecl] Hilfe Eclipse.

[Fis02] Oliver Fischer. Aus alt mach neu; refactoring verbessert software. iX, 4:151, 2002.

[Fow00] Martin Fowler. Refactoring, Wie Sie das Design vorhandener

Software verbessern. Addison-Wesley, 2000.

[GHJV96] Erich Gamma, Richard Helm, Rakph Johnson, and John Vlissides. Entwurfsmuster, Elemente wiederverwendbarer objektorientierter Software. Addison-Wesley, 1996.

[Har04] Dirk Hartmann. Methodenextraktion für java, 2004. [ref] http://www.refactoring.com.

[Sch03] Thomas Schoen. Runderneuerung, ein Überblick über refactoring und dessen einsatz bei der java-entwicklung. Javamagazin, 08, 2003.

Abbildung 1: Hochsetzen 20