Skip to main content
 首页 » 编程设计

Java 建造者模式

2022年07月19日27wuhuacong

1.建造者模式简介

建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式,它提供了一种创
建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。
主要解决:主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变
化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
何时使用:一些基本部件不会变,而其组合经常变化的时候。
如何解决:将变与不变分离开。

优点:(1)建造者独立,易扩展。(2)便于控制细节风险。
缺点:(1)产品必须有共同点,范围有限制。 (2)如内部变化复杂,会有很多的建造类。
使用场景:(1)需要生成的对象具有复杂的内部结构。 (2)需要生成的对象内部属性本身相互依赖。

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


2.创建者模式Demo
去肯德基,汉堡、可乐、薯条、炸鸡翅等是不变的,而其组合是经常变化的,生成出所谓的"套餐"。

继承关系图:

import java.util.ArrayList; 
import java.util.List; 
 
interface Packing { 
    public String pack(); 
} 
 
class Wraper implements Packing { 
    public String pack() { 
        return "Wraper"; 
    } 
} 
 
class Bottle implements Packing { 
    public String pack() { 
        return "Bottle"; 
    } 
} 
 
interface Item { 
    public String name(); 
    public Packing pack(); 
    public float price();  
} 
 
 
abstract class Burger implements Item { 
    @Override 
    public Packing pack() { 
        return new Wraper(); //效果是什么? 
    } 
} 
 
class VegBurger extends Burger { 
    @Override 
    public String name() { 
        return "VegBurger"; 
    } 
    @Override 
    public float price() { 
        return 30.0f; 
    } 
} 
 
class NonVegBurger extends Burger { 
    @Override 
    public String name() { 
        return "NonVegBurger"; 
    } 
    @Override 
    public float price() { 
        return 38.0f; 
    } 
} 
 
abstract class ColdDrink implements Item { 
    @Override 
    public Packing pack() { 
        return new Bottle(); //效果是什么? 
    } 
} 
 
class Coke extends ColdDrink { 
    @Override 
    public String name() { 
        return "Coke"; 
    } 
    @Override 
    public float price() { 
        return 5.0f; 
    } 
} 
 
class Pepsi extends ColdDrink { 
    @Override 
    public String name() { 
        return "Pepsi"; 
    } 
    @Override 
    public float price() { 
        return 6.0f; 
    } 
} 
 
 
class Meal { 
    private ArrayList<Item> items = new ArrayList<Item>(); 
 
    public void addItem(Item item) { 
        items.add(item); 
    } 
 
    public float mealPrice() { 
        float totalPrice = 0.0f; 
        for (Item i : items) { 
            totalPrice += i.price(); 
        } 
        return totalPrice; 
    } 
 
    public String mealItemList() { 
        String s = ""; 
        for (Item i : items) { 
            s += "Name: "; 
            s += i.name(); 
            s += ", Packing: "; 
            s += i.pack().pack(); /*i.pack()返回的是Wraper类对象*/ 
            s += ", Price: "; 
            s += i.price(); 
            s += "\n"; 
        } 
        return s; 
    } 
} 
 
class MealBuilder { 
    public static Meal perpareVegMeal() { 
        Meal meal = new Meal(); 
        meal.addItem(new VegBurger()); /*VegBurger是Item类的孙子,同样能表现出多态*/ 
        meal.addItem(new Coke()); 
        meal.addItem(new Pepsi()); /*若这个套餐中又加了一杯百世可乐,直接在这里加上一行即可。*/ 
        return meal; 
    } 
    public static Meal perpareNonVegMeal() { 
        Meal meal = new Meal(); 
        meal.addItem(new NonVegBurger()); 
        meal.addItem(new Pepsi()); 
        return meal; 
    } 
} 
 
public class BuilderPatternDemo { 
    public static void main(String args[]) { 
        Meal meal1 = MealBuilder.perpareVegMeal(); 
        System.out.print(meal1.mealItemList()); 
        System.out.println("TotalPrice: " + meal1.mealPrice()); 
 
        Meal meal2 = MealBuilder.perpareNonVegMeal(); 
        System.out.print(meal2.mealItemList()); 
        System.out.println("TotalPrice: " + meal2.mealPrice()); 
    } 
 
} 
 
/* 
执行结果: 
Name: VegBurger, Packing: Wraper, Price: 30.0 
Name: Coke, Packing: Bottle, Price: 5.0 
Name: Pepsi, Packing: Bottle, Price: 6.0 
TotalPrice: 41.0 
Name: NonVegBurger, Packing: Wraper, Price: 38.0 
Name: Pepsi, Packing: Bottle, Price: 6.0 
TotalPrice: 44.0 
*/

参考:http://www.runoob.com/design-pattern/builder-pattern.html


本文参考链接:https://www.cnblogs.com/hellokitty2/p/10663436.html