建造者模式
他的本质主要是:
分离了组件的构造(由builder来负责),和装配(由Director负责),从而构造出复杂的对象,这个模式使用于:某个对象构建过程复杂的情况下使用
建造模式可以将一个产品的内部表象（internal representation）与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。
由于实现了构建和装配的解耦。不同的构建器和不同的装配器 可以组合成很多不同的对象。也就是实现了构建算法、装配 算法的解耦，实现了更好的复用
场景:
在日常开发中,有时候我们需要一个复杂的对象.由于需求的原因.但是其中各部分的子对象经常变化,但是我们可以让他们组合起来相对简单稳定
使用场景. 1.我们需要很多零件 2.我们要把这些零件组装起来 当然在工作中,可能要和工厂模式搭配起来使用
代码:
这些实例可以使用简单工厂模式来生成不同的发动机 座椅啊.轮胎啊.
/**
* 汽车
* @Created by xiaodao
*/
public class Car {
private Seat seat;
private Engine engine;//发动机
private Tyre tyre;//轮胎
public Car(Seat seat, Engine engine, Tyre tyre) {
this.seat = seat;
this.engine = engine;
this.tyre = tyre;
}
public Seat getSeat() {
return seat;
}
public void setSeat(Seat seat) {
this.seat = seat;
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public Tyre getTyre() {
return tyre;
}
public void setTyre(Tyre tyre) {
this.tyre = tyre;
}
}
/**
* @Created by xiaodao
* 引擎实例
*/
public class Engine {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Engine(String name) {
this.name = name;
}
}
/**
* @Created by xiaodao
* 座椅
*/
public class Seat {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Seat(String name) {
this.name = name;
}
}
/**
* @Created by xiaodao
*轮胎
*/
public class Tyre {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Tyre(String name) {
this.name = name;
}
}
builder接口:
/**
* @Created by xiaodao
* 构建接口 这里也可以是抽象方法
*/
public interface CarBuilder {
/**
* 构建引擎
*
* @return
*/
Engine builderEngine();
Seat builderSeat();
Tyre builderTyre();
}
builder实现类:
/**
* @Created by xiaodao
*/
public class AudiCarBuilderImpl implements CarBuilder {
@Override
public Engine builderEngine() {
return new Engine("奥迪引擎");
}
@Override
public Seat builderSeat() {
return new Seat("奥迪座椅");
}
@Override
public Tyre builderTyre() {
return new Tyre("奥迪轮胎");
}
}
direactor:用来引入builder类的引用.他不知道builder的子类是什么
/**
* @Created by xiaodao
*/
public class CarDirector {
private CarBuilder builder;
public CarDirector(CarBuilder builder) {
this.builder = builder;
}
/**
* 装配汽车
* @return
*/
public Car directCar(){
Engine engine = builder.builderEngine();
Seat seat = builder.builderSeat();
Tyre tyre = builder.builderTyre();
return new Car(seat,engine,tyre);
}
}
调用者:
public class Client {
public static void main(String[] args) {
CarDirector carDirector = new CarDirector(new AudiCarBuilderImpl());
Car car = carDirector.directCar();
System.out.println(car.getEngine().getName());
System.out.println(car.getSeat().getName());
System.out.println(car.getTyre().getName());
}
}
奥迪引擎
奥迪座椅
奥迪轮胎
类图:
登场角色
builder角色负责定义用户生成实例的接口
concreteBuilder(具体的builder) concreteBuilder角色是实现了Builder接口的类.定义了具体的方法
director(监工) 负责使用builder角色的接口来生成实例,他不依赖与Builder的子类 无论子类如何定义都不影响 director的使用
client 具体的调用者
这里我们可以把car 的各种属性变成工厂模式
总结:
建造者模式与抽象工厂模式相似.(director 和abstractFactory 的实现类)今天下午与同事讨论半天总是在这方面比较模糊.欢迎大家踊跃评论.
个人感觉工厂模式是用于创建什么样的对象
建造模式就用来怎么创建对象
工厂方法模式和建造者模式都属于对象创建类模式，都用来创建类的对象。但它们之间的区别还是比较明显的。
下面来自某位群友的讲解
● 意图不同
在工厂方法模式里，我们关注的是一个产品整体，如超人整体，无须关心产品的各部分是如何创建出来的；但在建造者模式中，一个具体产品的产生是依赖各个部件的产生以及装配顺序，它关注的是“由零件一步一步地组装出产品对象”。简单地说，工厂模式是一个对象创建的粗线条应用，建造者模式则是通过细线条勾勒出一个复杂对象，关注的是产品组成部分的创建过程。
● 产品的复杂度不同
工厂方法模式创建的产品一般都是单一性质产品，如成年超人，都是一个模样，而建造者模式创建的则是一个复合产品，它由各个部件复合而成，部件不同产品对象当然不同。这不是说工厂方法模式创建的对象简单，而是指它们的粒度大小不同。一般来说，工厂方法模式的对象粒度比较粗，建造者模式的产品对象粒度比较细。 两者的区别有了，那在具体的应用中，我们该如何选择呢？是用工厂方法模式来创建对象，还是用建造者模式来创建对象，这完全取决于我们在做系统设计时的意图，如果需要详细关注一个产品部件的生产、安装步骤，则选择建造者，否则选择工厂方法模式。
原文地址：https://www.cnblogs.com/bj-xiaodao/p/10831441.html