1. Définition et diagramme de modélisation UML

Séparer la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.

2. Scénarios d'utilisation :

Plusieurs composants ou parties peuvent être assemblés en un seul objet, mais les résultats d'opération obtenus sont les mêmes.

La classe produit est très complexe, ou différents ordres d'appel dans la classe produit produisent des effets différents.

L'initialisation d'un objet est particulièrement complexe, par exemple en utilisant plusieurs constructeurs, ou en ayant de nombreux paramètres, tous avec des valeurs par défaut.

3. Classes principales

  • (1) Classe produit abstraite : ordinateur.
  • (2) Builder : le Builder abstrait, qui standardise l'assemblage du produit. Les sous-classes implémentent généralement le processus d'assemblage spécifique.
  • (3) MacbookBuilder : la classe Builder concrète, la classe qui crée spécifiquement des objets.
  • (4) Directror : unifie le processus d'assemblage.

Se concentrer sur l'assemblage d'un ordinateur, principalement l'assemblage de l'unité centrale, la configuration du système d'exploitation et la configuration du moniteur.

4. Utilisation spécifique

4.1 Classe abstraite Computer

Computer.java

public abstract class Computer { protected String mBoard; protected String mDisplay; protected String mOs; protected Computer(){ } public void setBoard(String board){ mBoard=board; } public void setDisplay(String display) { this.mDisplay = display; } public abstract void setOs() ; @Override public String toString() { return "Computer{" + "mBoard='" + mBoard + '\'' + ", mDisplay='" + mDisplay + '\'' + ", mOs='" + mOs + '\'' + '}'; } }

4.2 Classe de produit concret MacBook

MacBook.java

public class MacBook extends Computer{ protected MacBook() { } @Override public void setOs() { mOs="Mac OS X 12"; } }

4.3 Monteur abstrait

Builder.java

public abstract class Builder { abstract void buildBoard(String board); abstract void buildDisplay(String display); abstract void buildOs(); abstract Computer build(); }

4.4 Monteur concret

MacBookBuilder.java

public class MacBookBuilder extends Builder { private Computer mComputer=new MacBook(); @Override void buildBoard(String board) { mComputer.setBoard(board); } @Override void buildDisplay(String display) { mComputer.setDisplay(display); } @Override void buildOs() { mComputer.setOs(); } @Override Computer build() { return mComputer; } }

4.5 Classe Director, responsable de la construction spécifique de Computer

Director.java

public class Director { Builder mBuilser=null; public Director(Builder builer) { this.mBuilser = builer; } public void construct(String board,String display){ mBuilser.buildDisplay(display); mBuilser.buildBoard(board); mBuilser.buildOs(); } }

4.6 Utilisation spécifique

Test.java

public class Test { public static void main(String[] args){ Builder builder=new MacBookBuilder(); Director pcDirector=new Director(builder); pcDirector.construct("Intel Motherboard","Retina Display"); Computer computer = builder.build(); System.out.println(computer.toString()); } }

5. Résumé

Afin de construire de manière flexible des objets complexes, l'objet possédera plusieurs variables membres. Lorsqu'il est appelé de l'extérieur, il n'est ni nécessaire ni pratique de créer toutes les variables membres en une seule fois. Dans ce cas, utiliser plusieurs constructeurs pour construire des objets est difficile à maintenir. À ce stade, le patron de conception Builder résout ce problème en créant les objets dans la méthode build() et en transmettant le builder. Le builder conserve les variables membres de l'objet transmis.

Auteur : OneXzgj

Lien : https://www.jianshu.com/p/f958ba891467