Come spostare un metodo da una classe in un'altra classe quando due classi non sono affatto correlate

Question

Sto cercando di ridimensionare un codice suddividendo una classe in diverse altre classi. per farlo voglio spostare alcuni metodi già esistenti nella mia vecchia classe in una nuova classe. Ma questi metodi vengono indirizzati in molti punti e l'aggiornamento manuale dei riferimenti sembra noioso. Quindi c'è un modo per spostare metodi e aggiornare i loro riferimenti in eclissi?

Answer 1

Se si utilizza uno degli IDE standard (ad esempio Eclipse o IntelliJ IDEA), tutti hanno una semplice opzione di menu per farlo (a seconda di come è organizzato il codice).

Se si passa a ciascun metodo e si fa clic con il tasto destro del mouse sul suo nome, il menu ha un'opzione "Refactor", che porta all'opzione "Sposta". Seleziona quello e segui le istruzioni.

Quanto sopra è particolarmente facile per i metodi statici. Per quelli non statici, potrebbe essere necessario eseguire una sottoclasse o passare i riferimenti agli oggetti appropriati in giro. Anche così, l'opzione "Refactor -> Move" è un buon inizio.

Answer 2

se si utilizza l'eclissi IDE, il refactor ti aiuterà.

Answer 3

vorrei fare in questo modo:

1. garantire che il vostro prove di lavoro e il codice di essere ri-presi è coperto. Se non si hanno test di scrittura dei test. Sono la tua corda di sicurezza.
2. Utilizzare la ripetizione del modello superclasse per creare la nuova classe a cui si desidera spostare alcuni metodi.
3. Utilizzare il metodo di rielaborazione metodi di pull-up per spostare i metodi insieme alle variabili necessarie alla superclasse. Ora vedrai se i metodi che vuoi spostare e le variabili di istanza hanno dipendenze rispetto agli altri metodi che non vuoi spostare. Se è così, devi prima rompere queste dipendenze.
4. Trova tutto il codice client che dovrebbe utilizzare la nuova classe estratta anziché la "vecchia" classe e riscriverlo nella nuova classe estratta.
5. Rimuovere la relazione "estende" tra le due classi. Ora il codice cliente dovrebbe funzionare o hai perso qualcosa.

anche un buon libro per imparare ad applicare modelli ri-factoring è Working Effectively with Legacy Code

Answer 4

ce l'ha alcuna della vostra soddisfazione

package com.hussi.stackOverFlow; 
class ClassOne { 

    public void methodInClassOne(String stringParam) 
    { 
     ClassTwo classTwoObj = new ClassTwo(); 
     classTwoObj.methodInClassTwo(stringParam); 
    } 

} 


class ClassTwo { 

    public void methodInClassTwo(String stringParam) 
    { 
     System.out.println(stringParam); 
    } 

} 


public class ClassThree { 

    public static void main(String[] args) 
    { 
     ClassOne objClassOne = new ClassOne(); 
     // calling method of class two in class one 
     objClassOne.methodInClassOne("pass this String value"); 

    } 

} 

Answer 5

1. Copia il metodo nella nuova classe.
2. Sostituire il corpo del metodo nella vecchia classe con una chiamata nella nuova classe.
3. In linea il vecchio metodo.

Questo è tutto ciò che serve. Potrebbe non essere così semplice, perché nei passaggi 1 e 2 potrebbe essere necessario aggiungere argomenti e/o rendere il metodo statico, ma questa è l'essenza di come farlo.

Answer 6

Ti mostrerò il processo che seguo. Considerate tale codice:

public class GodClass { 
    public someInstanceMethodToMove() { 
     // some code 1 
    } 

    public static someStaticMethodToMove() { 
     // some code 2 
    } 

    public static void main(String[] args) { 
     GodClass c = ...; 
     c.someInstanceMethodToMove(); 
     GodClass.someStaticMethodToMove(); 
    } 
} 

creare la nuova classe:

public class SingleResponsibilityClass { 
} 

Il metodo statico può essere spostato direttamente al SingleResponsibilityClass utilizzando Refactor>Move... refactoring di Eclipse come descritto da Prabhakaran:

public class GodClass { 
    public someInstanceMethodToMove() { 
     // some code 1 
    } 

    public static void main(String[] args) { 
     GodClass c = ...; 
     c.someInstanceMethodToMove(); 
     SingleResponsibilityClass.someStaticMethodToMove(); 
    } 
} 

public class SingleResponsibilityClass { 
    public static someStaticMethodToMove() { 
     // some code 2 
    } 
} 

Per il metodo di istanza, il processo è un po 'più complesso. Leggere sotto.

Estrarre un metodo di someInstanceMethodToMove() e Diamo il nome someInstanceMethodToMove2():

public class GodClass { 
    public someInstanceMethodToMove() { 
     someInstanceMethodToMove2(); 
    } 

    private someInstanceMethodToMove2() { 
     // some code 1 
    } 

    // ... 
} 

Utilizzare il SingleResponsibilityClass nel metodo originale:

public class GodClass { 
    public someInstanceMethodToMove() { 
     someInstanceMethodToMove2(new SingleResponsibilityClass()); 
    } 

    private someInstanceMethodToMove2(SingleResponsibilityClass obj) { 
     // some code 1 
    } 

    // ... 
} 

Nota: è importante che SingleResponsibilityClass è un parametro del metodo di istanza da spostare, altrimenti Eclipse non lo sposterà in questo tipo. Da lì, fate clic destro su someInstanceMethodToMove2() e selezionare Refactor>Move..., selezionare il tipo di SingleResponsibilityClass nella procedura guidata, quindi applicare:

public class GodClass { 
    public someInstanceMethodToMove() { 
     new SingleResponsibilityClass().someInstanceMethodToMove2(); 
    } 

    // ... 
} 

public class SingleResponsibilityClass { 
    private someInstanceMethodToMove2() { 
     // some code 1 
    } 

    public static someStaticMethodToMove() { 
     // some code 2 
    } 
} 

Quindi fare clic destro sul SingleResponsibilityClass 'someInstanceMethodToMove2() metodo e Refactor>Rename a someInstanceMethodToMove(): pubblico class GodClass { public someInstanceMethodToMove() { new SingleResponsibilityClass(). someInstanceMethodToMove(); }

// ... 
} 

public class SingleResponsibilityClass { 
    private someInstanceMethodToMove() { 
     // some code 1 
    } 

    public static someStaticMethodToMove() { 
     // some code 2 
    } 
} 

quindi fare clic destro sul GodClass 'someInstanceMethodToMove() metodo e Refactor>Inline:

public class GodClass { 
    public static void main(String[] args) { 
     GodClass c = ...; 
     new SingleResponsibilityClass().someInstanceMethodToMove(); 
     SingleResponsibilityClass.someStaticMethodToMove(); 
    } 
} 

public class SingleResponsibilityClass { 
    private someInstanceMethodToMove() { 
     // some code 1 
    } 

    public static someStaticMethodToMove() { 
     // some code 2 
    } 
}