Mise à jour //
J'ai remarqué que IntelliJ a une option "Generate" pour générer des méthodes de délégués. Créer une nouvelle classe:
public class MyDecoratorClass {
private MyInterfaceWithManyMethods myInterface;
}
Puis marquer MyInterface, allez dans Menu> code> délégué, sélectionnez toutes les méthodes que vous voulez envelopper et c'est tout.
// Fin de la mise à jour
Vous pouvez essayer le "Refonte" -> "Remplacer l'héritage avec la délégation" refactoring. Il devrait être capable de faire ça, comme ça. Je l'appelle "Code avec Alt + Entrée"
Allez à l'interface pour laquelle vous souhaitez générer un décorateur.
public interface MyInterfaceWithManyMethods {
void method1();
void method2();
void method3();
}
Appuyez sur Alt + Entrée, sélectionnez "Mettre en oeuvre l'interface", donnez un nom à votre décorateur comme "MyDecorator". Cela vous donne
public class MyDecorator implements MyInterfaceWithManyMethods {
public void method1() {
}
public void method2() {
}
public void method3() {
}
}
Dans la nouvelle classe, sélectionnez le nom de la classe, puis « Refactor » -> « Remplacer l'héritage avec la délégation », sélectionnez votre interface, cochez tous les noms de méthode, appuyez sur Entrée. Vous obtiendrez:
public class MyDecorator {
private final MyObject object = new MyObject();
public void method1() {
object.method1();
}
public void method2() {
object.method2();
}
public void method3() {
object.method3();
}
private class MyObject implements MyInterfaceWithManyMethods {
public void method1() {
}
public void method2() {
}
public void method3() {
}
}
}
Supprimez manuellement la classe interne et l'initialiseur d'objet. Vous obtenez:
public class MyDecorator {
public void method1() {
object.method1();
}
public void method2() {
object.method2();
}
public void method3() {
object.method3();
}
}
Appuyez sur Alt + Entrée sur le « objet » qui est maintenant marqué en rouge, sélectionnez « Créer champ », sélectionnez MyInterfaceWithManyMethods.
public class MyDecorator {
private MyInterfaceWithManyMethods object;
public void method1() {
object.method1();
}
public void method2() {
object.method2();
}
public void method3() {
object.method3();
}
}
Sélectionnez la variable d'objet, appuyez sur Alt + Entrée, sélectionnez "Ajouter constructeur Paramètre":
public class MyDecorator {
private MyInterfaceWithManyMethods object;
public MyDecorator(MyInterfaceWithManyMethods object) {
this.object = object;
}
public void method1() {
object.method1();
}
public void method2() {
object.method2();
}
public void method3() {
object.method3();
}
}
Vous voyez tout cela se fait avec quelques coups de Alt + Entrée. Lit comme beaucoup de travail mais cela peut être fait en moins de 20 secondes. Si vous avez juste 2 ou 3 méthodes, vous pourriez être plus rapide avec un template live, cependant si vous avez beaucoup de méthodes avec des signatures complexes, vous obtiendrez un résultat de travail en environ 20 secondes avec cette méthode. Alt + Entrée roches simplement: D
Je ne trouve pas comment cela fonctionne lorsque vous voulez créer une classe à partir de zéro –
J'ai ajouté une description complète pour vous. –
Thx +1 pour la réponse complète :).J'ai écrit un modèle de fichier parce que lorsque le modèle est créé, il suffit de créer le fichier, puis seulement un "Alt + Inser". Le temps de création devrait être presque le même que celui de votre solution, mais avec moins de manipulations au clavier. –