Wie refactor Konstanten zu Enums in Eclipse?

Question

Wie refactor Java-Konstanten zu Enums mit Eclipse?

fand ich keine integrierte Funktionalität in Eclipse: http://code.google.com/p/constants-to-enum-eclipse-plugin/: http://help.eclipse.org/juno/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Freference%2Fref-menu-refactor.htm

ich ein Plugin gefunden. Ich frage mich, ob das Plugin der Weg ist oder jemand einen besseren Ansatz verwendet.

Ich konnte immer eine ENUM-Klasse erstellen ich einen Schnitt & die Konstanten einfügen, die im Jahr 2012 mühsam mich bitte nicht an einem anderen IDE zeigt, bin ich

Answer 1

Hier sind eine Reihe von automatisierten und manuellen Schritten, um dieses Refactoring durchzuführen.

Schritt 1 Encapsulate Feld auf der Konstanten

Schritt 2 (Optional) Umbenennen die Konstanten. Tun Sie dies, wenn Sie die Namen wiederverwenden wollen.

Schritt 3 (Manuell) Erstellen Sie die Enumeration mit den Werten der Konstanten. Geben Sie der Aufzählung eine getValue-Methode, die die Konstante zurückgibt.

Schritt 4 (manuell) Ersetzen Sie den Rückgabewert in den Gettern durch getValue von der Enumeration.

Schritt 5 Inline die Getter. Wählen Sie "Alle Referenzen" und "Delete method declaration".

Schritt 6 Inline die Konstanten. Wählen Sie "Alle Referenzen" und "Konstante Deklaration löschen".

Sie können nach 6 aufhören, wenn Sie wollen, aber es gibt noch mehr zu tun, um die Macht der Enums zu nutzen.

Schritt 7 Ersetzen Sie für jede Methode, die enum.getValue() als Parameter verwendet, die Konstante mit der Enumeration.

Schritt 7a Change Method Signature, um die Enum als Parameter hinzuzufügen.

Schritt 7b (manuell) Übergeben Sie die enum-Instanz als neuen Parameter neben dem getValue-Aufruf. Stellen Sie sicher, dass Sie alle Instanzen finden oder dass später Probleme auftreten.

Schritt 7c (manuell) Verwenden Sie in der Methode den neuen enum-Parameter anstelle der Konstante. Wenn Sie einen Anruf in Schritt 7b verpasst haben, werden Ihre Tests hier fehlschlagen.

Schritt 7d Ändern Sie die Methodensignatur, um die alte Konstante zu entfernen.

Schritt 8 (Manuell) Bestimmen Sie für jede Verwendung von enum.getValue() in boolescher Logik, ob Sie stattdessen die enum verwenden können.

Schritt 9 Wenn die Methode getValue nicht mehr verwendet wird, kann sie entfernt werden.

Schritt 9a (Manual) Löschen der nicht verwendete GetValue-Methode

Schritt 9b (Manual) Feld löschen und Zuordnung in den Konstruktor.

Schritt 9c Ändern Sie die Methodensignatur, um den Wert aus dem Aufzählungskonstruktor zu entfernen.

Schritt 9d (manuell) Wenn keine anderen Parameter, entfernen Sie den Enum-Konstruktor.

---

Zum Beispiel:

public class Initial { 
public static final String CONSTANT1 = "value1"; 
public static final String CONSTANT2 = "value2"; 

public void method(String aConstant) 
{ 
    if(aConstant.equals(CONSTANT2)) 
    { 
     //do something 
    } 
} 

public void anotherMethod() 
{ 
    method(CONSTANT1); 
} 

} 

Schritt 1

private static final String CONSTANT1 = "value1"; 
private static final String CONSTANT2 = "value2"; 

public void method(String aConstant) 
{ 
    if(aConstant.equals(getConstant2())) 
    { 
     //do something 
    } 
} 

public void anotherMethod() 
{ 
    method(getConstant1()); 
} 

public static String getConstant1() { 
    return CONSTANT1; 
} 

public static String getConstant2() { 
    return CONSTANT2; 
} 

Schritt 2 Rename Constants

private static final String _CONSTANT1 = "value1"; 
private static final String _CONSTANT2 = "value2"; 
... 
public static String getConstant1() { 
    return _CONSTANT1; 
} 

public static String getConstant2() { 
    return _CONSTANT2; 
} 

Schritt 3 erstellen Enum

01.235.

public static enum AnEnum { 
    CONSTANT1(_CONSTANT1), CONSTANT2(_CONSTANT2); 

    private final String value; 

    AnEnum(String aValue) 
    { 
     value = aValue; 
    } 

    public String getValue() 
    { 
     return value; 
    } 
} 

Schritt 4 Rückgabewert in Constant Getter

public static String getConstant1() { 
    return AnEnum.CONSTANT1.getValue(); 
} 

public static String getConstant2() { 
    return AnEnum.CONSTANT2.getValue(); 
} 

Schritt 5 Inline die konstanten Getter

public void method(String aConstant) 
{ 
    if(aConstant.equals(AnEnum.CONSTANT2.getValue())) 
    { 
     //do something 
    } 
} 

public void anotherMethod() 
{ 
    method(AnEnum.CONSTANT1.getValue()); 
} 

Schritt 6 Inline die Konstanten

public static enum AnEnum { 
    CONSTANT1("value1"), CONSTANT2("value2"); 

Schritt 7a Änderungsmethode Signiture Ersetzen enum als Parameter hinzufügen.

public void method(String aConstant, AnEnum theEnum) 
    .... 
    public void anotherMethod() 
{ 
    method(AnEnum.CONSTANT1.getValue(), null); 
} 

Schritt die Enum-Instanz als neue Parameter neben dem getValue 7b Pass

ruft

public void anotherMethod() 
{ 
    method(AnEnum.CONSTANT1.getValue(), AnEnum.CONSTANT1); 
} 

Schritt 7c sie die neuen Enum Parameter anstelle des alten übergebenen Wertes.

 if(theEnum.getValue().equals(AnEnum.CONSTANT2.getValue())) 
    { 

Schritt 7d ändern Methode Unterschrift die alte Konstante

public void method(AnEnum theEnum) 
.... 

public void anotherMethod() 
{ 
    method(AnEnum.CONSTANT1); 
} 

Schritt 8 Für jede Verwendung der enum.getValue() in der Booleschen Logik entfernen bestimmen, ob Sie die Enum stattdessen verwenden können.

 if(theEnum.equals(AnEnum.CONSTANT2)) 
    { 
     //do something 
    } 

Schritt 9a der nicht verwendete GetValue-Methode Schritt 9b (Manual) Feld löschen und Zuordnung im Konstruktor löschen. Schritt 9c Ändern Sie die Methodensignatur, um den Wert aus dem Aufzählungskonstruktor zu entfernen. Schritt 9d (manuell) Wenn keine anderen Parameter, entfernen Sie den enum Konstruktor.

public static enum AnEnum { 
    CONSTANT1, CONSTANT2; 
} 

So schließlich der Code sieht wie folgt aus:

public class Step9d { 

public static enum AnEnum { 
    CONSTANT1, CONSTANT2; 
} 

public void method(AnEnum theEnum) 
{ 
    if(theEnum.equals(AnEnum.CONSTANT2)) 
    { 
     //do something 
    } 
} 

public void anotherMethod() 
{ 
    method(AnEnum.CONSTANT1); 
} 

} 

Answer 2

;-) schlechte Gewohnheiten ändern zu alt Refactoring ändert niemals das "externe Verhalten"!

Zum Beispiel:

public enum Test { 
    NAME1("abc"); 

    Test(String name) {} 

    public static final String _NAME1="abc"; 
    public static void main(String[] args) { 
     String k = Test._NAME1; 
     String m = Test.NAME1; 
    } 
} 

Wenn Sie _NAME1 zu NAME1 (ENUM) Refactoring, stürzt der Code auf Instantiierung m. Das Refactoring wäre niemals erfolgreich!