constructeurs de refactor dans setters dans java

Question

J'ai refactorisé ma méthode en utilisant "Introduire un paramètre" car il acceptait beaucoup de variables. mais maintenant tous les appelants ont cosntructor en ligne comme

this.somemethod(new MyParam("a", "b","c","d"); 

je voudrais factoriser en remplaçant constructeur avec setters comme

MyParam myParam= new MyParam(); 
myParam.setA("a");........ 
. 
. 
this.somemethod(myParam); 

Est-il someway pour ce faire ??

il y avait un bug similaire rapporté sur Eclipse https://bugs.eclipse.org/bugs/show_bug.cgi?id=105324

Answer 1

Si je vous comprends bien, vous voulez que votre constructeur actuel passe automatiquement à un constructeur sans paramètre avec des appels ultérieurs aux setters. Je le ferais en plaçant les appels setter dans le constructeur en cours, en vérifiant qu'ils sont tous public, puis en exécutant la refonte de la méthode Inline sur le constructeur. Ah, mais Eclipse ne vous laissera pas faire ça.Vous pouvez donc écrire:

public static A newA(int a, int b) { 
    A aa = new A(); 
    aa.setA(a); 
    aa.setB(b); 
    return aa; 
} 

(Bien sûr, vous devez écrire le constructeur vide, aussi), puis remplacer manuellement tous

a = new A(3,2); 

avec

a = A.newA(3,2); 

et puis vous pouvez intégrer la méthode newA(). Ça ne vaut vraiment pas la peine, je pense. Mais je ne connais pas de manière plus automatisée.

Answer 2

pourquoi tu fais cette chose laide?

Pourquoi ne pas faire quelque chose comme

public void sometMethod(Object.. parameters) 

Et vous pouvez y accéder comme

this.someMethod("a", "b", "c", "d", "e", "f"); //:) 
//or 
this.someMethod("a"); 

Et pour répondre à votre solution ... vous pouvez .. utilisant la réflexion ...

Vous pouvez accéder à votre méthode dynamique utilisant la réflexion ... link here

Answer 3

Y a-t-il un moyen de le faire?

Oui, ont des fonctions setter comme ce retour this afin que vous puissiez les enchaîner:

public class MyParam { 
    private String foo; 
    private int bar; 
    // ...and so on... 

    public MyParam() { 
     // Set reasonable defaults here 
    } 

    public MyParam letFoo(String foo) { 
     this.foo = foo; 
     return this; 
    } 

    public MyParam letBar(int bar) { 
     this.bar = bar; 
     return this; 
    } 

    // ...and so on... 
} 

Utilisation:

someFunction(new MyParam() 
      .letFoo("foo") 
      .letBar(42) 
      .letXyz(...) 
      // ...and so on... 
); 

Ceci est particulièrement utile lorsque A) Il y a par défaut raisonnables pour plusieurs des "paramètres" et donc les appelants ne devront pas nécessairement utiliser tous les setters, et B) Il y a beaucoup de paramètres donc il est facile de se perdre dans l'ordre des choses.

Je l'ai utilisé letXyz plutôt que setXyz parce que Sean fait remarquer dans les commentaires, setXyz utilise la convention de nommage JavaBean, mais setters JavaBeans ne devrait pas avoir une valeur de retour. (Pour plus d'informations, voir this other question here on SO et ses réponses.)