Partage de technologie

Modèle de générateur de modèles de conception

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Le modèle Builder dans les modèles de conception est un modèle de conception de création d'objets couramment utilisé, principalement utilisé pour résoudre des problèmes complexes de construction d'objets. Voici une introduction détaillée au mode constructeur :

1. Définition

Le modèle de construction sépare la construction d'un objet complexe de sa représentation, permettant au même processus de construction de créer différentes représentations. En d’autres termes, il fonctionne en décomposant le processus de construction d’objets complexes en une série d’étapes simples et en permettant aux utilisateurs de créer différents objets en spécifiant l’ordre et les paramètres de ces étapes.

2. Diagramme de classe et structure

Diagramme de classes

En mode constructeur, les rôles suivants sont généralement inclus :

  1. Rôle du produit (Produit): Représente un objet complexe en cours de construction, contenant généralement plusieurs composants.
  2. Constructeur abstrait: Définir une interface abstraite pour créer divers composants d'objets produit.
  3. Constructeur de béton: Implémenter l'interface Builder, compléter les méthodes de création spécifiques de chaque composant d'un produit complexe, et définir une interface qui renvoie le produit final.
  4. Directeur : Responsable de l'appel des méthodes de construction et d'assemblage des composants dans l'objet constructeur pour terminer la création d'objets complexes. Cela n’implique pas d’informations spécifiques sur le produit, cela dissocie simplement le client du constructeur.

3. Scénarios applicables

Le modèle de générateur convient aux scénarios suivants :

  1. La structure de l'objet est complexe: Lorsque l'objet à construire a une structure interne complexe et contient plusieurs propriétés et méthodes, l'utilisation du modèle de générateur peut simplifier le processus de construction.
  2. Le processus de construction est complexe: Lorsque le processus de construction d'un objet implique plusieurs étapes et que l'ordre et les paramètres de ces étapes peuvent être différents, le modèle de constructeur peut fournir un processus de construction clair.
  3. Création et usage découplés: Lorsque vous souhaitez séparer les processus de création et d'utilisation des objets afin que les utilisateurs n'aient qu'à se soucier de la représentation finale de l'objet et n'aient pas besoin de se soucier des détails de la création de l'objet, le modèle de générateur est un bon choix.

4. Avantages et inconvénients

avantage
  1. Bonne encapsulation: Encapsulez le processus de construction d'objets complexes dans le constructeur. Le client n'a qu'à spécifier le type et les paramètres de la construction pour obtenir le produit final sans connaître les détails du processus de construction.
  2. Bonne évolutivité: Si vous devez ajouter un nouveau type de build ou modifier le processus de build, il vous suffit d'ajouter ou de modifier la classe builder, ce qui n'affectera pas le code client.
  3. Grande flexibilité: Flexibilité pour créer différentes instances de produit en modifiant l'ordre ou les paramètres de construction du constructeur.
défaut
  1. Augmenter le nombre de cours: En raison de la nécessité de créer plusieurs classes telles que des interfaces de constructeur, des classes de constructeur spécifiques et des classes de commandant, le nombre de classes dans le système peut être augmenté.
  2. Difficulté en modification interne: Si la structure interne du produit change, plusieurs classes de constructeur peuvent devoir être modifiées, augmentant ainsi le coût de maintenance du système.

5. Exemple

Dans l’exemple suivant, nous utiliserons le modèle constructeur pour concevoir un système de rénovation de maison.Nous définirons unHouse Les classes sont des objets complexes qui contiennent plusieurs éléments de décoration (tels que plafonds, peintures, sols, carrelages, etc.).Ensuite, nous définissons unHouseBuilder Interface, contenant des méthodes abstraites pour créer ces composants. Ensuite, nous créons des classes de constructeurs spécifiques pour chaque style de décoration spécifique (tel que le style européen de luxe, le style pastoral de luxe léger, le minimaliste moderne).Enfin, nous passerons unDirectorpour guider le processus de construction, mais cela n'est peut-être pas nécessaire dans cet exemple puisque nous pouvons définir la logique de construction complète directement dans la classe builder.

Cependant, pour démontrer la notion de rôle de chef d'orchestre, nous retiendrons unDirectorclasse, mais à titre indicatif seulement, en fait, le processus de construction peut être effectué directement dans la classe constructeur.

  1. // 房屋类  
  2. public class House {  
  3.     private String ceiling; // 吊顶  
  4.     private String paint;   // 涂料  
  5.     private String floor;   // 地板  
  6.     private String tiles;   // 地砖  
  7.   
  8.     // 私有构造函数  
  9.     private House() {}  
  10.   
  11.     // Getter 方法  
  12.     public String getCeiling() {  
  13.         return ceiling;  
  14.     }  
  15.   
  16.     public String getPaint() {  
  17.         return paint;  
  18.     }  
  19.   
  20.     public String getFloor() {  
  21.         return floor;  
  22.     }  
  23.   
  24.     public String getTiles() {  
  25.         return tiles;  
  26.     }  
  27.   
  28.     // 建造者接口  
  29.     public interface HouseBuilder {  
  30.         HouseBuilder buildCeiling(String ceiling);  
  31.         HouseBuilder buildPaint(String paint);  
  32.         HouseBuilder buildFloor(String floor);  
  33.         HouseBuilder buildTiles(String tiles);  
  34.         House build();  
  35.     }  
  36.   
  37.     // 豪华欧式建造者  ,注意是静态内部类
  38.     public static class LuxuryEuropeanBuilder implements HouseBuilder {  
  39.         private House house;  
  40.   
  41.         public LuxuryEuropeanBuilder() {  
  42.             this.house = new House();  
  43.         }  
  44.   
  45.         @Override  
  46.         public HouseBuilder buildCeiling(String ceiling) {  
  47.             house.ceiling = "豪华欧式吊顶: " + ceiling;  
  48.             return this;  
  49.         }  
  50.   
  51.         @Override  
  52.         public HouseBuilder buildPaint(String paint) {  
  53.             house.paint = "豪华欧式涂料: " + paint;  
  54.             return this;  
  55.         }  
  56.   
  57.         @Override  
  58.         public HouseBuilder buildFloor(String floor) {  
  59.             house.floor = "豪华欧式地板: " + floor;  
  60.             return this;  
  61.         }  
  62.   
  63.         @Override  
  64.         public HouseBuilder buildTiles(String tiles) {  
  65.             house.tiles = "豪华欧式地砖: " + tiles;  
  66.             return this;  
  67.         }  
  68.   
  69.         @Override  
  70.         public House build() {  
  71.             return house;  
  72.         }  
  73.     }  
  74.   
  75.     // ... 可以为其他风格创建类似的建造者类  
  76.   
  77.     // 指挥者类（可选，这里主要用于展示概念）  
  78.     public static class Director {  
  79.         private HouseBuilder builder;  
  80.   
  81.         public Director(HouseBuilder builder) {  
  82.             this.builder = builder;  
  83.         }  
  84.   
  85.         // 这里可以添加方法来指导建造过程，但在这个例子中，我们直接在建造者中完成了所有工作  
  86.         public House constructHouse() {  
  87.             // 假设这是由指挥者指导的步骤，但在这里我们直接返回建造者的结果  
  88.             return builder  
  89.                 .buildCeiling("水晶吊灯")  
  90.                 .buildPaint("金色镶边涂料")  
  91.                 .buildFloor("大理石地板")  
  92.                 .buildTiles("马赛克地砖")  
  93.                 .build();  
  94.         }  
  95.     }  
  96.   
  97.     // 主函数，用于演示  
  98.     public static void main(String[] args) {  
  99.         HouseBuilder luxuryBuilder = new LuxuryEuropeanBuilder();  
  100.         // Director director = new Director(luxuryBuilder); // 如果使用指挥者  
  101.   
  102.         House house = luxuryBuilder  
  103.                 .buildCeiling("水晶吊灯")  
  104.                 .buildPaint("金色镶边涂料")  
  105.                 .buildFloor("大理石地板")  
  106.                 .buildTiles("马赛克地砖")  
  107.                 .build();  
  108.   
  109.         System.out.println("Ceiling: " + house.getCeiling());  
  110.         System.out.println("Paint: " + house.getPaint());  
  111.         System.out.println("Floor: " + house.getFloor());  
  112.         System.out.println("Tiles: " + house.getTiles());  
  113.     }  
  114. }

Veuillez noter que dans cet exemple,DirectorLes classes n'ajoutent pas vraiment beaucoup de valeur puisque toute la logique de construction est déjà encapsulée dansHouseBuilder L'interface est implémentée. Mais dans des applications plus complexes,DirectorLes classes peuvent être utilisées pour encapsuler l'ordre et la logique du processus de génération, en particulier lorsque le processus de génération s'étend sur plusieurs générateurs.

6. Conclusion

Grâce à l'introduction ci-dessus, nous pouvons voir que le modèle de construction présente de grands avantages lors de la construction d'objets complexes. Il améliore l'encapsulation et l'évolutivité du code en séparant le processus de construction de la représentation, et réduit également le temps entre le client et le produit spécifique. . degré de couplage entre.

Si cet article est utile à votre étude, n'oubliez pas de l'aimer et de le récupérer.

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail