介绍
这种类型的设计模式属于创建型模式。
意图:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
主要解决:主要解决在软件系统中,有时候面临着”一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
适用场景:一些基本部件不会变,而其组合经常变化的时候。
例如:去肯德基,汉堡、可乐、薯条、炸鸡翅等是不变的,而其组合是经常变化的,生成出所谓的”套餐”。
实现
图解
建造者模式
interface Item{
public String name();
public float price();
}
class Burger implements Item{
@Override
public String name() {
return "Burger";
}
@Override
public float price() {
return 15.0f;
}
}
class ColdDrink implements Item{
@Override
public String name() {
return "ColdDrink";
}
@Override
public float price() {
return 8.0f;
}
}
class Chips implements Item{
@Override
public String name() {
return "Chips";
}
@Override
public float price() {
return 10.0f;
}
}
class Meal{
List<Item> items = new ArrayList<Item>();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.println(", Price : "+item.price());
}
}
}
abstract class Builder{
public abstract Meal getMeal();
public abstract Meal setMeal(List<Item> itemList);
}
class MealBuilder extends Builder{
Meal meal = new Meal();
@Override
public Meal getMeal() {
return meal;
}
@Override
public Meal setMeal(List<Item> itemList) {
meal.items.clear();
meal.items.addAll(itemList);
return meal;
}
}
class Director {
private Builder mealBuilder = new MealBuilder();
public Meal getMealA(){
List<Item> itemList = new ArrayList<Item>();
itemList.add(new Burger());
itemList.add(new Chips());
mealBuilder.setMeal(itemList);
return mealBuilder.getMeal();
}
public Meal getMealB(){
List<Item> itemList = new ArrayList<Item>();
itemList.add(new Burger());
itemList.add(new ColdDrink());
mealBuilder.setMeal(itemList);
return mealBuilder.getMeal();
}
}
public class Client {
public static void main(String[] args) {
Director director = new Director();
System.out.println("MealA...");
Meal mealA = director.getMealA();
mealA.showItems();
System.out.println("MealB...");
Meal mealB = director.getMealB();
mealB.showItems();
}
}
非建造者模式
interface Item{
public String name();
public float price();
}
class Burger implements Item{
@Override
public String name() {
return "Burger";
}
@Override
public float price() {
return 15.0f;
}
}
class ColdDrink implements Item{
@Override
public String name() {
return "ColdDrink";
}
@Override
public float price() {
return 8.0f;
}
}
class Chips implements Item{
@Override
public String name() {
return "Chips";
}
@Override
public float price() {
return 10.0f;
}
}
class Meal{
List<Item> items = new ArrayList<Item>();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.println(", Price : "+item.price());
}
}
}
public class Client {
// 不使用建造者模式,创建和表示在一块,没有分离
public static void main(String[] args) {
System.out.println("MealA...");
Meal mealA = new Meal();
mealA.addItem(new Burger());
mealA.addItem(new Chips());
mealA.showItems();
System.out.println("MealB...");
Meal mealB = new Meal();
mealA.addItem(new Burger());
mealA.addItem(new ColdDrink());
mealB.showItems();
}
}
总结
四个要素
产品类:一般是一个较为复杂的对象,也就是说创建对象的过程比较复杂,一般会有比较多的代码量。在本类图中,产品类是一个具体的类,而非抽象类。实际编程中,产品类可以是由一个抽象类与它的不同实现组成,也可以是由多个抽象类与他们的实现组成。
抽象建造者:引入抽象建造者的目的,是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法,一个用来建造产品,一个是用来返回产品。
建造者:实现抽象类的所有未实现的方法,具体来说一般是两项任务:组建产品;返回组建好的产品。
导演类:负责调用适当的建造者来组建产品,导演类一般不与产品类发生依赖关系,与导演类直接交互的是建造者类。一般来说,导演类被用来封装程序中易变的部分。优点
使得建造代码与表示代码分离,由于建造者隐藏了该产品是如何组装的,所以若需要改变一个产品的内部表示,只需要再定义一个具体的建造者就可以了。
缺点
如内部变化复杂,会有很多的建造类。