建造者模式
将一个复杂对象的创建与它的表示分离,使得同样的构建过程可以创建不同的表示
四种角色
- Product 产品角色 指的是一个具体的产品对象
- Builder 抽象建造者 创建一个产品对象的各个部件的接口/抽象类
- ConcreteBuilder 具体建造者 实现或继承抽象建造者接口 具体的构建和装配各个部件
- Director 指挥者 构建一个使用Builder接口的对象,主要用于创建一个复杂的对象,负责指挥构建一个工程,决定了工程如何构建,按照什么顺序构建
场景
- 需要生成的对象具有复杂的内部结构
- 需要生成的对象内部属性本身相互依赖
- 与不可变对象配合使用
优点
- 建造者独立,易于扩展
- 便于控制细节风险
实现
使用继承的方式实现
public class ExtendTest {
public static void main(String[] args) {
AbstractBook book = new MacBookPro();
book.produceBook();
System.out.println("========================================");
book = new XiaoMiBook();
book.produceBook();
}
}
// 定义一个抽象类
abstract class AbstractBook {
public abstract void fillwithCpu();
public abstract void fillwithGpu();
public void produceBook() {
fillwithCpu();
fillwithGpu();
}
}
// 定义具体实现类1
class MacBookPro extends AbstractBook {
@Override
public void fillwithCpu() {
System.out.println("我是高端的MacBook Pro,我使用的是迄今为止地表最强的M2 MAX芯片,我可太快太牛逼了...");
}
@Override
public void fillwithGpu() {
System.out.println("我是高端的MacBook Pro,我使用的是迄今为止地表最强的M2 MAX GPU,对图形这块,我可是没输过...");
}
}
// 定义具体实现类2
class XiaoMiBook extends AbstractBook {
@Override
public void fillwithCpu() {
System.out.println("我是小米笔记本,我的CPU是还不错的13代英特尔酷睿i5处理器...");
}
@Override
public void fillwithGpu() {
System.out.println("我是小米笔记本,我的GPU是还不错的Geforce GTX3050Ti...");
}
}
使用建造者模式
public class BuilderTest2 {
public static void main(String[] args) {
Book build = new BookBuilder().buildTotalPage(1).buildTotalWord(2).build();
System.out.println(build);
Book build2 = new BookBuilder().buildTotalPage(3).buildTotalWord(4).build();
System.out.println(build2);
}
}
class Book{
private Integer totalPage;
private Integer totalWord;
public Book(){
}
public Book(BookBuilder builder){
this.totalPage = builder.totalPage;
this.totalWord = builder.totalWord;
}
public String toString(){
return "Book[totalPage="+this.totalPage+",totalWord="+this.totalWord+"]";
}
}
final class BookBuilder{
public Integer totalPage;
public Integer totalWord;
public BookBuilder buildTotalPage(Integer totalPage) {
this.totalPage = totalPage;
return this;
}
public BookBuilder buildTotalWord(Integer totalWord) {
this.totalWord = totalWord;
return this;
}
public Book build(){
return new Book(this);
}
}
简化对象实现
public class BuilderTest {
public static void main(String[] args) {
Director director = new Director(new IphoneBuilder());
MobilePhone construct = director.construct();
System.out.println(construct);
Director director1 = new Director(new SanXinBuilder());
MobilePhone construct1 = director1.construct();
System.out.println(construct1);
}
}
@Getter
@Setter
class MobilePhone{
private String name;
private String cpu;
private String screen;
public MobilePhone(){}
@Override
public String toString(){
return this.name+"-"+this.cpu+"-"+this.screen;
}
}
// 定义builder接口
abstract class Builder {
public static final MobilePhone mobilePhone = new MobilePhone();
private String name;
private String cpu;
private String screen;
abstract void buildName();
abstract void buildCpu();
abstract void buildScreen();
public MobilePhone createPhone(){
return mobilePhone;
}
}
class IphoneBuilder extends Builder{
@Override
public void buildName() {
mobilePhone.setName("iphoneName");
}
@Override
public void buildCpu() {
mobilePhone.setCpu("iphoneCpu");
}
@Override
public void buildScreen() {
mobilePhone.setScreen("iphoneScreen");
}
@Override
public MobilePhone createPhone() {
return mobilePhone;
}
}
class SanXinBuilder extends Builder{
@Override
public void buildName() {
mobilePhone.setName("三星1.0");
}
@Override
public void buildCpu() {
mobilePhone.setCpu("三星8G");
}
@Override
public void buildScreen() {
mobilePhone.setScreen("三星56寸");
}
@Override
public MobilePhone createPhone() {
return mobilePhone;
}
}
// 创建Director 通过有参构造器注入一个具体的builder,在核心方法construct方法完成各个组件的具体组装,并返回最后组装出来的对象
class Director{
private Builder builder;
public Director(Builder builder){
this.builder = builder;
}
public MobilePhone construct(){
builder.buildName();
builder.buildCpu();
builder.buildScreen();
return builder.createPhone();
}
}