1. Préface
Aujourd'hui, nous abordons le patron Builder. Ce Builder est en fait très similaire au patron Template, mais il présente des différences. C'est-à-dire que, dans le patron Template, la classe parente opère sur les implémentations des sous-classes et gère une tâche au sein de la classe parente. Cependant, dans le patron Builder, ni la classe parente ni les sous-classes ne se soucient de la manière de le gérer ; à la place, une autre classe est utilisée pour réaliser la combinaison organique de ces méthodes. La responsabilité de cette classe est :superviseur, qui spécifie exactement comment combiner organiquement ces méthodes. Dans la classe superviseur (Director), la classe parente est intégrée par composition, puis les opérations de la classe parente sont appelées pour accomplir abstraitement une tâche. C'est la beauté de la programmation orientée interface (abstraite). Bien sûr, ce Builder peut être une interface ou une classe abstraite ; ici, nous utilisons une classe abstraite.

2. Code du patron Builder
Classe abstraite Builder :
Builder.java
HtmlBuilder classe d'implémentation :
HtmlBuilder.java
Classe d'implémentation TextBuilder :
TextBuilder.java
Director, classe superviseur:
Director.java
Classe principale :
Director.java
Résultats d'exécution


Ou :

3. Résumé
En ce qui concerne le patron Builder, nous devons clairement le distinguer du patron de méthode gabarit. En fait, cela revient à savoir qui assume la responsabilité du « superviseur ». Dans le patron de méthode gabarit, la classe parente assume cette responsabilité, tandis que dans Builder, une autre classe dédiée effectue de telles opérations. L’avantage est l’isolation des classes. Par exemple, dans Main, l’utilisateur n’a aucune idée que la classe abstraite Builder existe ; de même, le Director (superviseur) ne se soucie pas du tout de savoir de quelle classe d’implémentation il s’agit, car n’importe laquelle sera convertie en classe parente puis traitée (l’idée de la programmation orientée vers l’abstraction). Ainsi, l’isolation est bien réalisée. De même, cette conception favorise la réutilisation : mieux l’isolation est réalisée, plus la réutilisation est pratique. Nous pouvons tout à fait imaginer que s’il existe un autre superviseur qui utilise une méthode de construction différente pour assembler ces événements complexes, alors nous n’avons pas besoin de modifier le code d’origine ; nous avons seulement besoin d’ajouter une telle classe de superviseur, de définir les méthodes correspondantes, puis de l’utiliser dans Main. Ce type d’idée nous permet d’éviter de modifier le code source, ce qui rend la réutilisation (Builder et ses sous-classes) très pratique. De même, si nous voulons ajouter une nouvelle sous-classe de Builder, il suffit de remplir selon les méthodes de la classe parente et d’ajouter nos propres méthodes, sans modifier le code du tout. C’est aussi une forme de réutilisation. Par conséquent, cette idée de réutilisation (composants) se retrouve partout dans les patrons de conception. Son essence est une forte cohésion et un faible couplage, le développement par composants, en essayant de ne pas modifier le code d’origine, et en disposant d’une extensibilité. Une fois que nous avons compris cela, revenons à la méthode gabarit : la responsabilité est entièrement placée dans la classe parente. Si la responsabilité doit changer, la méthode de responsabilité dans la classe parente doit être modifiée ; cela modifie le code d’origine et n’est pas propice à la réutilisation. C’est aussi la différence essentielle entre les deux.
Adresse d'origine : https://www.cnblogs.com/zyrblog/p/9230630.html