1.
package com.java.builder;
/**
* 建造者模式 1. 开发中应用场景
* --- StringBuilder类的append方法
* ----SQL中 的PreparedStatement
* ----JDOM中 , DomBuilder SAXBuilder
* 2.本质: 分离了对象子组件的单独构造与装配 ,从而可以构造复杂的对象
* 适用于:
* 某个对象构建过程复杂的情况下使用 实现了 构建和装配的解耦,
* 不同的构造器 相同的装配 也可以做出不同的对象
* 相同的装配,不同的构造器也能建造出不同的对象
* 例如: 我们在建造一个复杂的产品航天飞船(有很多子组件)时,
* 问题是 装配这些子组件有很多步骤?开发过程也是一样
*/
public class AirShip {
private OrbitalModule orbitalModule;// 轨道舱
private Engine engine; // 发动机
private EscapeTower escapeTower; // 逃逸塔
public void launch(){
System.out.println("发射!");
}
/**
* getter and setter
*
*/
public OrbitalModule getOrbitalModule() {
return orbitalModule;
}
public void setOrbitalModule(OrbitalModule orbitalModule) {
this.orbitalModule = orbitalModule;
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public EscapeTower getEscapeTower() {
return escapeTower;
}
public void setEscapeTower(EscapeTower escapeTower) {
this.escapeTower = escapeTower;
}
}
class OrbitalModule {
private String name;
public OrbitalModule(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Engine {
private String name;
public Engine(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class EscapeTower {
private String name;
public EscapeTower(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.java.builder;
/**
* 我们要建造一个飞船
* 提供这飞船 建造的顶级接口
* 接口中定义 各个部件的方法
*
*/
public interface AirShipBuilder {
Engine builderEngine();
OrbitalModule builderOrbitalModule();
EscapeTower builderEscapeTower();
}
package com.java.builder;
public class AirShipBuilderImpl implements AirShipBuilder{
/**
* 每一个子组件都有一个有参String name的构造
*/
public Engine builderEngine() {
System.out.println("构建发动机。。。。");
return new Engine("发动机----");
}
public OrbitalModule builderOrbitalModule() {
System.out.println("构建轨道舱。。。。。");
return new OrbitalModule("轨道舱----");
}
public EscapeTower builderEscapeTower() {
System.out.println("构建逃逸塔。。。。");
return new EscapeTower("轨道舱----");
}
}
package com.java.builder;
public interface AirShipdDirector {
/**
* 组装飞船
*/
AirShip directAirShip();
}
package com.java.builder;
public class AirShipDirectorImpl implements AirShipdDirector{
private AirShipBuilder builder;
public AirShipDirectorImpl(AirShipBuilder builder) {
this.builder = builder;
}
/**
* 完成组装 ,通过builder来实现
*/
public AirShip directAirShip() {
Engine e= builder.builderEngine();
OrbitalModule o=builder.builderOrbitalModule();
EscapeTower et=builder.builderEscapeTower();
/**
* 装配成飞船对象
*/
AirShip ship= new AirShip();
ship.setEngine(e);
ship.setEscapeTower(et);
ship.setOrbitalModule(o);
return ship;
}
}
飞船通过装配derictor来进行--(装配时将子组件set进来)返回最终的AirShip
package com.java.builder;
public class Main {
public static void main(String[] args) {
AirShipdDirector director = new AirShipDirectorImpl(new AirShipBuilderImpl());
AirShip ship = director.directAirShip();
System.out.println(ship.getEngine().getName());
ship.launch();
}
}
一个类如果包含有很多的 类对象 ,而A类里面有很多的属性 , 导致该类比较复杂,
如果我们 只是 简单的 T t= new T( ) 则 t 里面都是空的, 比较简单的类一般是 setName(xx)注入
class T{
A a;
B b;
C c;
D d;
}
优点:
- 易于解耦
将产品本身与产品创建过程进行解耦,可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。 - 易于精确控制对象的创建
将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰 - 易于拓展
增加新的具体建造者无需修改原有类库的代码,易于拓展,符合“开闭原则“
缺点:
- 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似;如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。
- 如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。