2010-12-01 54 views
15

Parfois, je crée une classe de décorateur comme celui-ci:Est-ce que IntelliJ peut créer automatiquement une classe de décorateur?

class MyInterfaceDecorator implements MyInterface { 
    private final MyInterface delegate; 
    ... constructor taking a MyInterface instance ... 

    @Override 
    public Object someInterfaceMethod(Some argument) { 
     return delegate.someInterfaceMethod(argument); 
    } 

    ... etc, more methods here... 
} 

Peut-IntelliJ créer automatiquement cette classe pour moi?

Répondre

30

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

+0

Je ne trouve pas comment cela fonctionne lorsque vous voulez créer une classe à partir de zéro –

+2

J'ai ajouté une description complète pour vous. –

+0

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. –

1

Vous pouvez peut-être ajouter un modèle de fichier comme:

class ${NAME} implements ${INTERFACE} { 
    private final ${INTERFACE} delegate; 

    public ${NAME}(final ${INTERFACE} delegate) { 
     this.delegate = delegate; 
} 

et puis quand vous avez créé le fichier en utilisant ce modèle, il suffit d'utiliser Alt + Inser et délégué du choix des méthodes. Ce n'est pas parfait, mais cela pourrait être un raccourci

+0

Pas mal, mais ce serait sympa s'il pouvait aussi générer les méthodes à implémenter (déléguer des appels à l'objet délégué). –