建造者模式:将一个复杂对象的创建和他的表示相互分离,使得同样的创建过程可以创建不同的表示。(个人理解:两个对象内方法一样的但是实现不同细节不同)。
建造者模式的作用:用于创建一些复杂的对象,这些对象内部构建顺序通常是稳定的,但是内部的构建通常面临着复杂的变化。
下面代码会有自行车的抽象类,继承抽象类实现类(并组合具体的产品),指挥者,测试客户端
//具体的摩拜
public class MobaiS {
private String wheel;
private String seal;
private String brake;
public String getWheel() {
return wheel;
}
public void setWheel(String wheel) {
this.wheel = wheel;
}
public String getSeal() {
return seal;
}
public void setSeal(String seal) {
this.seal = seal;
}
public String getBrake() {
return brake;
}
public void setBrake(String brake) {
this.brake = brake;
}
@Override
public String toString() {
return "MobaiS{" +
"wheel='" + wheel + '\'' +
", seal='" + seal + '\'' +
", brake='" + brake + '\'' +
'}';
}
}
//具体的ofo,和摩拜类似
public class OfoS {
private String wheel;
private String seal;
private String brake;
...
}
//抽象为创建自行车指定的组装流程类
public abstract class Bike {
public abstract void wheel();
public abstract void seal();
public abstract void brake();
}
//具体的建造者实现抽象接口
public class Mobai extends Bike {
private MobaiS mobaiS= new MobaiS();
public MobaiS GetMobaiS() {
return mobaiS;
}
@Override
public void wheel() {
mobaiS.setWheel("俩摩拜的轮子");
}
@Override
public void seal() {
mobaiS.setSeal("一个摩拜座位");
}
@Override
public void brake() {
mobaiS.setBrake("一个摩拜刹车");
}
}
//ofo类似
public class Ofo extends Bike {
private OfoS ofoS = new OfoS();
public OfoS GetOfoS(){
return ofoS;
}
...
}
//创建指挥者
public class BikeDirector {
public Bike bike;
public void setBike(Bike bike) {
this.bike = bike;
}
public void Createbike(){
this.bike.wheel();
this.bike.seal();
this.bike.brake();
}
}
//测试
public class test {
public static void main(String[] args) {
BikeDirector bd = new BikeDirector();
/*创建一辆摩拜*/
Mobai m = new Mobai();
//m表示我们想要一个摩拜车子,我们便把请求交给指挥者,指挥者便通过多态帮我们把
//这个想法交给具体的建造者
bd.setBike(m);
//进行内部复杂的处理
bd.Createbike();
//我们通过建造者类拿到了想要的摩拜单车
MobaiS ms = m.GetMobaiS();
System.out.println(ms);
/*创建一辆ofo*/
Ofo o = new Ofo();
bd.setBike(o);
bd.Createbike();
OfoS os = o.GetOfoS();
System.out.println(os);
}
}