建造者模式简介
- 模式属于创建型模式，它提供了一种创建对象的最佳方式。
- 使用多个简单的对象一步一步构建成一个复杂的对象。
- 一个Builder类会一步一步构造最终的对象。该Builder类是独立于其他对象的。
指挥者模式产品类Product
//产品
public class Product {
private String one;
private String two;
private String three;
public String getOne() {
return one;
}public void setOne(String one) {
this.one = one;
}public String getTwo() {
return two;
}public void setTwo(String two) {
this.two = two;
}public String getThree() {
return three;
}public void setThree(String three) {
this.three = three;
}@Override
public String toString() {
return "Product{" +
"one='" + one + '\'' +
", two='" + two + '\'' +
", three='" + three + '\'' +
'}';
}
}抽象类Builder
//抽象的建造者
public abstract class Builder {
abstract void one();
//第一步工序abstract void two();
//第二步工序abstract void three();
//第三步工序abstract Product getProduct();
//完工，得到产品
}子类Worker
//具体的建造者：工人
public class Worker extends Builder {
private Product product;
public Worker() {
product = new Product();
}@Override
void one() {
product.setOne("第一步工序");
System.out.println("第一步工序");
}@Override
void two() {
product.setTwo("第二步工序");
System.out.println("第二步工序");
}@Override
void three() {
product.setThree("第三步工序");
System.out.println("第三步工序");
}@Override
Product getProduct() {
return product;
}
}指挥者类
//指挥者
public class Director {
//指挥工人生成产品
public Product build(Builder builder){
builder.one();
builder.two();
builder.three();
return builder.getProduct();
}
}测试类
public class Test {
public static void main(String[] args) {
//指挥者
Director director = new Director();
//指挥工人生产产品
Product product = director.build(new Worker());
System.out.println(product);
/**
* 输出结果：
* 第一步工序
* 第二步工序
* 第三步工序
* Product{one='第一步工序', two='第二步工序', three='第三步工序'}
*/
}
}测试结果
第一步工序
第二步工序
第三步工序
Product{one='第一步工序', two='第二步工序', three='第三步工序'}内部类模式产品类Product
//产品
public class Product {
private String one = "第一步工序";
private String two = "第二步工序";
private String three = "第三步工序";
public String getOne() {
return one;
}public void setOne(String one) {
this.one = one;
}public String getTwo() {
return two;
}public void setTwo(String two) {
this.two = two;
}public String getThree() {
return three;
}public void setThree(String three) {
this.three = three;
}@Override
public String toString() {
return "Product{" +
"one='" + one + '\'' +
", two='" + two + '\'' +
", three='" + three + '\'' +
'}';
}
}抽象类Builder
//抽象的建造者
public abstract class Builder {
abstract Builder one(String mes);
//第一步工序abstract Builder two(String mes);
//第二步工序abstract Builder three(String mes);
//第三步工序abstract Product getProduct();
//完工，得到产品
}子类Worker
//具体的建造者：工人
public class Worker extends Builder {
private Product product;
public Worker() {
product = new Product();
}@Override
Builder one(String mes) {
product.setOne(mes);
return this;
}@Override
Builder two(String mes) {
product.setTwo(mes);
return this;
}@Override
Builder three(String mes) {
product.setThree(mes);
return this;
}@Override
Product getProduct() {
return product;
}
}测试类
public class Test {
public static void main(String[] args) {
//工人
Worker worker = new Worker();
//生产产品
Product product = worker.getProduct();
System.out.println(product.toString());
/**
* 输出结果：
* Product{one='第一步工序', two='第二步工序', three='第三步工序'}
*///链式编程
product = worker.one("第一步额外工序").three("提前第三步工序").getProduct();
System.out.println(product);
/**
* 输出结果：
* Product{one='第一步额外工序', two='第二步工序', three='提前第三步工序'}
*/
}
}测试结果
Product{one='第一步工序', two='第二步工序', three='第三步工序'}
Product{one='第一步额外工序', two='第二步工序', three='提前第三步工序'}
