一篇带你了解建造者模式

[[413733]]

本文转载自微信公众号「我好困啊」，作者mengxin。转载本文请联系我好困啊公众号。

建造者模式：

将多个简单对象一步步的按照特定顺序创建出一个复杂对象。

意图

将一个复杂对象的构建过程与其表示分离。

主要解决

主要解决"复杂对象"的构建构成工作,这个"复杂对象"由多个子对象按照一定规则组成。

关键代码

建造者:将多个子对象进行组装。

使用场景

复杂对象由多个子对象组成。

代码实现

代码主要功能:定义两个子对象cat,dog,将这两个子对象通过建造者组装成对应的复杂对象pet。

1.定义各类"产品"

构建抽象产品接口

 1/** 
 2 * 抽象商品接口 
 3 */ 
 4public interface Item { 
 5 
 6    //商品名称 
 7    public String name(); 
 8    //商品价格 
 9    public Float price(); 
10    //默认行为 
11    public String canDO(); 
12} 

构建"cat"产品

1/** 
2 * Cat产品抽象类 
3 * 提供Cat默认行为 
4 */ 
5public abstract class Cat implements Item{ 
6 
7    public String canDO(){ 
8        return "miaomiao...."; 
9    } 
0} 

bigCat

 1/** 
 2 * big cat 
 3 */ 
 4public class BigCat extends Cat{ 
 5    @Override 
 6    public String name() { 
 7        return "big cat"; 
 8    } 
 9 
10    @Override 
11    public Float price() { 
12        return 500.0f; 
13    } 
14} 

smallCat

 1public class SmallCat extends Cat{ 
 2    @Override 
 3    public String name() { 
 4        return "small cat"; 
 5    } 
 6 
 7    @Override 
 8    public Float price() { 
 9        return 100.0f; 
10    } 
11} 

构建"dog"产品

1/** 
2 * Dog产品抽象类 
3 * 提供dog默认行为 
4 */ 
5public abstract class Dog implements Item{ 
6 
7    public String canDO(){ 
8        return "wangwang...."; 
9    } 
0} 

bigDog

 1/** 
 2 * big dog 
 3 */ 
 4public class BigDog extends Dog{ 
 5    @Override 
 6    public String name() { 
 7        return "big dog"; 
 8    } 
 9 
10    @Override 
11    public Float price() { 
12        return 1000.0f; 
13    } 
14} 

SmallDog

 1/** 
 2 * small dog 
 3 */ 
 4public class SmallDog extends Dog{ 
 5    @Override 
 6    public String name() { 
 7        return "small dog"; 
 8    } 
 9 
10    @Override 
11    public Float price() { 
12        return 200.0f; 
13    } 
14} 

2.定义抽象"套餐"

构建"pet"套餐

 1/** 
 2 * 宠物 
 3 */ 
 4public class Pet { 
 5 
 6    private List<Item> list = new ArrayList<>(); 
 7 
 8    //添加商品 
 9    public void addItem(Item item){ 
10        list.add(item); 
11    } 
12 
13    //获取所选宠物价格 
14    public float getCost(){ 
15        float cost = 0.0f; 
16        for (Item item : list) { 
17            cost += item.price(); 
18        } 
19        return cost; 
20    } 
21 
22    public void showPet(){ 
23        for (Item item : list) { 
24            System.out.print("Item : "+item.name()); 
25            System.out.print(", speak : "+item.canDO()); 
26            System.out.println(", Price : "+item.price()); 
27        } 
28    } 
29 
30} 

3.定义建造者将"产品"按照特定顺序构建成特定"套餐"

构建创建者，创建对应"套餐"

 1/** 
 2 * 建造者: 
 3 * 将现有的商品按照特点顺序组装成特定"套装" 
 4 */ 
 5public class PetBuilder { 
 6 
 7    //组装大宠物套装 
 8    public Pet buildBigPet(){ 
 9        Pet pet = new Pet(); 
10        pet.addItem(new BigCat()); 
11        pet.addItem(new BigDog()); 
12        return pet; 
13    } 
14 
15    //组装小宠物套装 
16    public Pet buildSmallPet(){ 
17        Pet pet = new Pet(); 
18        pet.addItem(new SmallDog()); 
19        pet.addItem(new SmallCat()); 
20        return pet; 
21    } 
22 
23} 

测试：

 1/** 
 2 * 测试建造者模式 
 3 */ 
 4public class Main { 
 5 
 6    public static void main(String[] args) { 
 7        PetBuilder petBuilder = new PetBuilder(); 
 8        //调用建造者构建Big套装 
 9        Pet bigPet = petBuilder.buildBigPet(); 
10        System.out.println("Big pet...."); 
11        bigPet.showPet(); 
12        System.out.println("Total cost:"+bigPet.getCost()); 
13 
14        //调用建造者构建Small套装 
15        Pet smallPet = petBuilder.buildSmallPet(); 
16        System.out.println("Small pet...."); 
17        smallPet.showPet(); 
18        System.out.println("Total cost:"+smallPet.getCost()); 
19    } 
20} 

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。