Condivisione della tecnologia

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

Il Builder Pattern nei design pattern è un design pattern di creazione di oggetti comunemente utilizzato, utilizzato principalmente per risolvere problemi complessi di costruzione di oggetti. Ecco un'introduzione dettagliata alla modalità builder:

1. Definizione

Il builder pattern separa la costruzione di un oggetto complesso dalla sua rappresentazione, consentendo allo stesso processo costruttivo di creare rappresentazioni diverse. In altre parole, funziona suddividendo il processo di costruzione di oggetti complessi in una serie di semplici passaggi e consentendo agli utenti di creare oggetti diversi specificando l'ordine e i parametri di questi passaggi.

2. Diagramma e struttura delle classi

Diagramma delle classi

Nella modalità builder, solitamente sono inclusi i seguenti ruoli:

1. Ruolo del prodotto (Prodotto): Rappresenta un oggetto complesso in fase di costruzione, solitamente contenente più componenti.
2. Costruttore astratto: definire un'interfaccia astratta per la creazione di vari componenti di oggetti di prodotto.
3. ConcreteBuilder: Implementare l'interfaccia Builder, completare i metodi di creazione specifici di ciascun componente di un prodotto complesso e definire un'interfaccia che restituisca il prodotto finale.
4. Direttore : Responsabile della chiamata ai metodi di costruzione e assemblaggio del componente nell'oggetto builder per completare la creazione di oggetti complessi. Non comporta informazioni specifiche sul prodotto, ma semplicemente disaccoppia il cliente dal costruttore.

3. Scenari applicabili

Il modello di creazione è adatto per i seguenti scenari:

1. La struttura dell'oggetto è complessa: quando l'oggetto da creare ha una struttura interna complessa e contiene più proprietà e metodi, l'utilizzo del modello di creazione può semplificare il processo di creazione.
2. Il processo di costruzione è complesso: Quando il processo di costruzione di un oggetto prevede più passaggi e l'ordine e i parametri di questi passaggi possono essere diversi, il modello di costruzione può fornire un processo di costruzione chiaro.
3. Creazione e utilizzo disaccoppiati: quando si desidera separare i processi di creazione e utilizzo degli oggetti in modo che gli utenti debbano preoccuparsi solo della rappresentazione finale dell'oggetto e non debbano preoccuparsi dei dettagli della creazione dell'oggetto, il modello builder è una buona scelta.

4. Vantaggi e svantaggi

vantaggio

1. Buon incapsulamento: Incapsulare il processo di costruzione di oggetti complessi all'interno del costruttore. Il cliente deve solo specificare il tipo e i parametri della costruzione per ottenere il prodotto finale senza conoscere i dettagli del processo di costruzione.
2. Buona scalabilità: se è necessario aggiungere un nuovo tipo di build o modificare il processo di build, è sufficiente aggiungere o modificare solo la classe builder, che non influirà sul codice client.
3. Elevata flessibilità: flessibilità per creare diverse istanze del prodotto modificando l'ordine di creazione o i parametri del builder.

discordanza

1. Aumentare il numero delle classi: A causa della necessità di creare più classi come interfacce costruttore, classi costruttore specifiche e classi comandante, il numero di classi nel sistema potrebbe essere aumentato.
2. Difficoltà nella modificazione interna: Se la struttura interna del prodotto cambia, potrebbe essere necessario modificare più classi di costruttori, aumentando i costi di manutenzione del sistema.

5. Esempio

Nell'esempio seguente utilizzeremo il modello Builder per progettare un sistema di ristrutturazione della casa.Definiremo aHouse Le classi sono oggetti complessi che contengono più componenti decorativi (come soffitti, vernici, pavimenti, piastrelle, ecc.).Quindi definiamo aHouseBuilder Interfaccia, contenente metodi astratti per la creazione di questi componenti. Successivamente, creiamo classi di costruttori specifiche per ogni stile di decorazione specifico (come stile europeo di lusso, pastorale di lusso leggero, minimalista moderno).Infine, passeremo aDirectorclass per guidare il processo di costruzione, ma potrebbe non essere necessario in questo esempio poiché possiamo definire la logica di costruzione completa direttamente nella classe builder.

Tuttavia, per dimostrare il concetto del ruolo del conduttore, manterremo aDirectorclass, ma solo a scopo illustrativo, infatti il ​​processo di costruzione può essere eseguito direttamente nella classe builder.

// 房屋类  
public class House {  
    private String ceiling; // 吊顶  
    private String paint;   // 涂料  
    private String floor;   // 地板  
    private String tiles;   // 地砖  
  
    // 私有构造函数  
    private House() {}  
  
    // Getter 方法  
    public String getCeiling() {  
        return ceiling;  
    }  
  
    public String getPaint() {  
        return paint;  
    }  
  
    public String getFloor() {  
        return floor;  
    }  
  
    public String getTiles() {  
        return tiles;  
    }  
  
    // 建造者接口  
    public interface HouseBuilder {  
        HouseBuilder buildCeiling(String ceiling);  
        HouseBuilder buildPaint(String paint);  
        HouseBuilder buildFloor(String floor);  
        HouseBuilder buildTiles(String tiles);  
        House build();  
    }  
  
    // 豪华欧式建造者  ,注意是静态内部类
    public static class LuxuryEuropeanBuilder implements HouseBuilder {  
        private House house;  
  
        public LuxuryEuropeanBuilder() {  
            this.house = new House();  
        }  
  
        @Override  
        public HouseBuilder buildCeiling(String ceiling) {  
            house.ceiling = "豪华欧式吊顶: " + ceiling;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildPaint(String paint) {  
            house.paint = "豪华欧式涂料: " + paint;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildFloor(String floor) {  
            house.floor = "豪华欧式地板: " + floor;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildTiles(String tiles) {  
            house.tiles = "豪华欧式地砖: " + tiles;  
            return this;  
        }  
  
        @Override  
        public House build() {  
            return house;  
        }  
    }  
  
    // ... 可以为其他风格创建类似的建造者类  
  
    // 指挥者类（可选，这里主要用于展示概念）  
    public static class Director {  
        private HouseBuilder builder;  
  
        public Director(HouseBuilder builder) {  
            this.builder = builder;  
        }  
  
        // 这里可以添加方法来指导建造过程，但在这个例子中，我们直接在建造者中完成了所有工作  
        public House constructHouse() {  
            // 假设这是由指挥者指导的步骤，但在这里我们直接返回建造者的结果  
            return builder  
                .buildCeiling("水晶吊灯")  
                .buildPaint("金色镶边涂料")  
                .buildFloor("大理石地板")  
                .buildTiles("马赛克地砖")  
                .build();  
        }  
    }  
  
    // 主函数，用于演示  
    public static void main(String[] args) {  
        HouseBuilder luxuryBuilder = new LuxuryEuropeanBuilder();  
        // Director director = new Director(luxuryBuilder); // 如果使用指挥者  
  
        House house = luxuryBuilder  
                .buildCeiling("水晶吊灯")  
                .buildPaint("金色镶边涂料")  
                .buildFloor("大理石地板")  
                .buildTiles("马赛克地砖")  
                .build();  
  
        System.out.println("Ceiling: " + house.getCeiling());  
        System.out.println("Paint: " + house.getPaint());  
        System.out.println("Floor: " + house.getFloor());  
        System.out.println("Tiles: " + house.getTiles());  
    }  
}

Tieni presente che in questo esempio,DirectorLe classi in realtà non aggiungono molto valore poiché tutta la logica di creazione è già incapsulataHouseBuilder L'interfaccia è implementata. Ma nelle applicazioni più complesse,DirectorLe classi possono essere utilizzate per incapsulare l'ordine e la logica del processo di compilazione, soprattutto quando il processo di compilazione si estende su più builder.

6. Conclusione

Dall'introduzione di cui sopra, si può vedere che il modello builder presenta grandi vantaggi quando si costruiscono oggetti complessi. Migliora l'incapsulamento e la scalabilità del codice separando il processo di costruzione dalla rappresentazione e riduce anche la comunicazione tra il cliente e lo specifico. prodotto. grado di accoppiamento tra.

Se questo articolo è utile al tuo studio, ricordati di mettere mi piace e collezionarlo.