正文

java设计模式学习笔记，三：建造者模式

 2022-03-23  737

关键词：

建造者模式：实现了构建和装配的解耦，即对象的各个子组件单独构建，再进行装配，从而建造完整对象。

该模式适用于构建较为复杂的对象（多个子组件）。

不同的构建者，使用相同的装配者，可以建造不同的对象实例。相同的构建者，不同的装配顺序，也可能建造出不同的对象实例。

举例：

　　汽车对象，子组件包括引擎、轮子和车体。

　　Audi汽车构建者，负责制造Audi牌各个子组件。BMW汽车构建者，负责制造BMW牌各个子组件。然后将子组件统一送至汽车装配者的生产线中进行组装，最后会建造出Audi牌汽车和BMW汽车。

以下代码实现：

　　首先，定义汽车类，及其子组件类。

  1 package com.corey.builder;
  2 
  3 /**
  4  * 汽车类---产品类
  5  * @author Corey
  6  *
  7  */
  8 public class Car {
  9     private Engine engine;
 10     private Wheel wheel;
 11     private CarBody body;
 12     
 13     public Engine getEngine() {
 14         return engine;
 15     }
 16     public void setEngine(Engine engine) {
 17         this.engine = engine;
 18     }
 19     public Wheel getWheel() {
 20         return wheel;
 21     }
 22     public void setWheel(Wheel wheel) {
 23         this.wheel = wheel;
 24     }
 25     public CarBody getBody() {
 26         return body;
 27     }
 28     public void setBody(CarBody body) {
 29         this.body = body;
 30     }
 31     
 32     public void Run(){
 33         System.out.println("启动汽车，开始行程！");
 34     }
 35     
 36     
 37 }
 38 
 39 /**
 40  * 发动机类
 41  * @author Corey
 42  *
 43  */
 44 class Engine {
 45     private String name;
 46 
 47     public Engine(String name) {
 48         super();
 49         this.name = name;
 50     }
 51 
 52     public String getName() {
 53         return name;
 54     }
 55 
 56     public void setName(String name) {
 57         this.name = name;
 58     }
 59     
 60 }
 61 
 62 /**
 63  * 车轮类
 64  * @author Corey
 65  *
 66  */
 67 class Wheel {
 68     private String name;
 69 
 70     public Wheel(String name) {
 71         super();
 72         this.name = name;
 73     }
 74 
 75     public String getName() {
 76         return name;
 77     }
 78 
 79     public void setName(String name) {
 80         this.name = name;
 81     }
 82     
 83 }
 84 
 85 /**
 86  * 车体类
 87  * @author Corey
 88  *
 89  */
 90 class CarBody {
 91     private String name;
 92 
 93     public CarBody(String name) {
 94         super();
 95         this.name = name;
 96     }
 97 
 98     public String getName() {
 99         return name;
100     }
101 
102     public void setName(String name) {
103         this.name = name;
104     }
105     
106 }

　　然后，定义汽车制造者接口。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 汽车制造者接口
 5  * @author Corey
 6  *
 7  */
 8 public interface CarBuilder {
 9     
10     String getBrand();
11     Engine buildEngine();
12     Wheel buildWheel();
13     CarBody buildCarBody();
14     
15     
16 }

　　分别实现Audi汽车制造者类和BMW汽车制造者类。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 奥迪汽车建造者---接口实现类
 5  * @author Corey
 6  *
 7  */
 8 public class AudiCarBuidler implements CarBuilder{
 9     
10 
11 
12     @Override
13     public Engine buildEngine() {
14         System.out.println("建造奥迪发动机！");
15         return new Engine("Audi发动机");
16     }
17 
18     @Override
19     public Wheel buildWheel() {
20         System.out.println("建造奥迪车轮！");
21         return new Wheel("Audi车轮");
22     }
23 
24     @Override
25     public CarBody buildCarBody() {
26         System.out.println("建造奥迪车体！");
27         return new CarBody("Audi车体");
28     }
29 
30     @Override
31     public String getBrand() {
32         return "Audi";
33     }
34 
35 }

 1 package com.corey.builder;
 2 
 3 public class BMWCarBuilder implements CarBuilder{
 4 
 5     @Override
 6     public String getBrand() {
 7         return "BMW";
 8     }
 9 
10     @Override
11     public Engine buildEngine() {
12         System.out.println("建造宝马发动机！");
13         return new Engine("BMW发动机");
14     }
15 
16     @Override
17     public Wheel buildWheel() {
18         System.out.println("建造宝马车轮！");
19         return new Wheel("BMW车轮");
20     }
21 
22     @Override
23     public CarBody buildCarBody() {
24         System.out.println("建造宝马车体！");
25         return new CarBody("BMW车体");
26     }
27 
28 }

　　定义汽车装配者类。

package com.corey.builder;

/**
 * 奥迪汽车组装者--接口实现类
 * @author Corey
 *
 */
public class CarDirector{

    private CarBuilder builder;
    
    public CarDirector(CarBuilder builder) {
        super();
        this.builder = builder;
    }

    public Car directCar() {
        Car car = new Car();
        car.setEngine(builder.buildEngine());
        car.setWheel(builder.buildWheel());
        car.setBody(builder.buildCarBody());
        String brand = builder.getBrand();
        System.out.println("组装" + brand + "汽车完成！");
        return car;
        
    }

}

由此，我们可以进行汽车生产了。

指定汽车制造商，送入汽车装配厂，生产汽车，上路。以下是测试代码：

 1 package com.corey.builder;
 2 
 3 public class Test {
 4 
 5     public static void main(String[] args) {
 6         
 7         CarBuilder builder = new AudiCarBuidler();
 8         CarDirector director = new CarDirector(builder);
 9         Car car = director.directCar();
10         System.out.println(car.getEngine().getName());
11         car.Run();
12         
13         System.out.println("----------------------------------");
14         
15         CarBuilder builder1 = new BMWCarBuilder();
16         CarDirector director1 = new CarDirector(builder1);
17         Car bmwCar = director1.directCar();
18         System.out.println(bmwCar.getEngine().getName());
19         bmwCar.Run();
20     }
21 }

运行结果：

建造奥迪发动机！
建造奥迪车轮！
建造奥迪车体！
组装Audi汽车完成！
Audi发动机
启动汽车，开始行程！
----------------------------------
建造宝马发动机！
建造宝马车轮！
建造宝马车体！
组装BMW汽车完成！
BMW发动机
启动汽车，开始行程！

至此，建造者模式完成。

Java框架中很多都是用建造者模式写的，一般都会以Builder结尾，常见的如StringBuilder。

设计模式学习笔记建造者模式和其他对象创建方式的区别(代码片段)

一、建造者模式介绍1.1建造者模式的定义建造者（Builder）模式指将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。它是把对象的构建和表述分离。也就是通过多... 查看详情

设计模式学习笔记-建造者模式

一、概述将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示；二、模式中的角色 Builder：为创建一个Product对象的各个部件指定抽象接口； ConcreteBuilder：实现B... 查看详情

从零开始学习java设计模式|创建型模式篇：建造者模式

在本讲，我们来学习一下创建型模式里面的最后一个设计模式，即建造者模式。概述建造者模式是指将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。读完这句话之后，我估计很多人... 查看详情

c#设计模式巩固笔记-建造者模式

前言写给自己-贵在坚持。建造者模式不复杂，但是想个形象的例子好难。介绍-建造者模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。实现建造者模式主要是应对复杂对象，在之前... 查看详情

java设计模式之建造者学习与掌握(代码片段)

...#xff0c;使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每... 查看详情

设计模式之建造者模式(代码片段)

本文由老王家组装电脑引出——建造者设计模式，详细介绍建造者模式的基本概念和实现代码，为了便于理解建造者模式，我们会对实际应用中的典型案例进行介绍。最后对比工厂模式和建造者模式之间的区别，让我们在实际使... 查看详情

设计模式之建造者模式(代码片段)

设计模式之建造者模式(三)　　今天来学习建造者模式,好像也有人叫生成器,一个意思.　　一概念　　建造者模式:使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创... 查看详情

尚硅谷设计模式学习---[建造者模式(builderpattern)](代码片段)

...#x1f680;🚀🚀尚硅谷传送门==>B站尚硅谷Java设计模式❤❤❤感谢尚硅谷❤❤❤🛴🛴🛴最近开始计划学习一下设计模式了,加油!!!目录📢情景引入🏡建造者模式使用建造者模式的jdk案例📢情... 查看详情

设计模式学习系列——建造者模式(代码片段)

建造者模式　　建造者模式（BuilderPattern）使用多个简单的对象一步一步构建成一个复杂的对象。　　优点： 1、建造者独立，易扩展。2、便于控制细节风险。　　缺点： 1、产品必须有共同点，范围有限制。2、如内... 查看详情

建造者模式（java与kotlin版）

前文推送设计模式简单工厂模式（Java与Kotlin版）工厂方法模式（Java与Kotlin版）抽象工厂模式（Java与Kotlin版） Kotlin基础知识Kotlin入门第一课：从对比Java开始Kotlin入门第二课：集合操作Kotlin入门第三课：数据类型初次尝... 查看详情

设计模式——建造者模式实例

设计模式（五）——建造者模式三、建造者模式实例1、快餐套餐实例快餐套餐一般含有主食、饮料、点心三部分组成，KFC快餐套餐与Mcdonald快餐套餐的生成过程大致都是一样的。每份套餐由主食、饮料、点心三... 查看详情

java设计模式之建造者学习与掌握(代码片段)

面试高频java设计模式-建造者模式

⭐️写在前面这里是温文艾尔的学习之路👍如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ👋博客主页🎉温文艾尔的学习小屋⭐️更多文章👨‍🎓请关注温文艾尔主页📝🍅文章发布日期&... 查看详情

从retrofit/okhttp源码学习设计模式-建造者模式(代码片段)

建造者模式首先我们先大致熟悉下通常的建造者模式建造者模式（BuilderPattern）也叫生成器模式，其定义如下：将一个对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式的通用... 查看详情

java设计模式-建造者模式

建造者模式概述建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。它关注如... 查看详情

设计模式实践笔记第三节：建造者模式(代码片段)

...，使得同样的构建过程可以创建不同的表示。大多数设计模式都不仅仅存在于IT世界，往往在现实生活中也有相当多的例子，建造者模式也不例外。builder的本意是建造者，通常用在建筑领域，小到瓦房单间ÿ... 查看详情