建造模式

最新推荐文章于 2025-05-31 21:26:49 发布

原创最新推荐文章于 2025-05-31 21:26:49 发布 · 549 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#建造 #设计 #模式 #设计者 #建造者

Java 专栏收录该内容

10 篇文章

订阅专栏

23种设计模式——建造模式

定义：

GOF给建造模式的定义为：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。也就是说，将构造复杂对象的过程与组成对象的部件解耦。

使用场所：

当要生成的对象有复杂的内部结构——比如多个对象组成；而系统中此产品的需求将来可能要改变产品对象的内部结构的构成，比如说产品的一些属性现在由一个小对象组成，而更改后的型号可能由N个小对象组成；而且不能将产品的内部结构完全暴露给客户程序，一个是为了可用性，二是为了安全因素；

组成：

抽象建造者对象：这个角色用来规范产品对象的各个组成部位的建造

具体建造者对象

指导者对象

产品对象

类图：

实现：

package com.abstractbuilder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
//不同的媒体形式
class Media extends ArrayList {
}
class Book extends Media {
};
class Magzine extends Media {
};
class WebSite extends Media {
};
class MediaItem {
private String s;
public MediaItem(String s) {
this.s = s;
}
public String toString() {
return s;
}
}
class Chapter extends MediaItem {
public Chapter(String s) {
super(s);
}
}
class Article extends MediaItem {
public Article(String s) {
super(s);
}
}
class WebItem extends MediaItem {
public WebItem(String s) {
super(s);
}
}
// 抽象建造者角色，它规范了所有媒体的构造过程
class MediaBuilder {
public void buildBase() {
};
public void addMediaItem(MediaItem item) {
}
public Media getFinishedMedia() {
return null;
}
}
// 具体建造者角色
class BookBuilder extends MediaBuilder {
private Book b;
@Override
public void buildBase() {
// TODO Auto-generated method stub
System.out.println("Building book framework");
b = new Book();
}
@Override
public void addMediaItem(MediaItem item) {
// TODO Auto-generated method stub
System.out.println("Adding Chapter " + item);
b.add(item);
}
@Override
public Media getFinishedMedia() {
// TODO Auto-generated method stub
return b;
}
}
class MagazineBuilder extends MediaBuilder {
private Magzine m;
@Override
public void buildBase() {
// TODO Auto-generated method stub
System.out.println("Building Magzine framework");
m = new Magzine();
}
@Override
public void addMediaItem(MediaItem item) {
// TODO Auto-generated method stub
System.out.println("Adding Chapter" + item);
m.add(item);
}
@Override
public Media getFinishedMedia() {
// TODO Auto-generated method stub
return m;
}
}
class WebSiteBuilder extends MediaBuilder {
private WebSite w;
public void buildBase() {
System.out.println("Building web site framework");
w = new WebSite();
}
public void addMediaItem(MediaItem webItem) {
System.out.println("Adding web item " + webItem);
w.add(webItem);
}
public Media getFinishedMedia() {
return w;
}
}
// 指导者角色，也叫做上下文
class MediaDirector {
private MediaBuilder mb;
public MediaDirector(MediaBuilder mb) {
// TODO Auto-generated constructor stub
this.mb = mb;
}
public Media produceMedia(List input) {
mb.buildBase();
for (Iterator it = input.iterator(); it.hasNext();) {
mb.addMediaItem((MediaItem) it.next());
}
return mb.getFinishedMedia();
}
}
public class BuilderMedia {
private List input = Arrays.asList(new MediaItem[] {
new MediaItem("Item1"), new MediaItem("Item2"),
new MediaItem("Item3"), new MediaItem("Item4") });
public void testBook() {
MediaDirector buildBook = new MediaDirector(new BookBuilder());
Media book = buildBook.produceMedia(input);
String result = "book:" + book;
System.out.println(result);
}
public void testMagazine() {
MediaDirector buildMagazine = new MediaDirector(new MagazineBuilder());
Media magazine = buildMagazine.produceMedia(input);
String result = "magazine: " + magazine;
System.out.println(result);
}
public void testWebSite() {
MediaDirector buildWebSite = new MediaDirector(new WebSiteBuilder());
Media webSite = buildWebSite.produceMedia(input);
String result = "web site: " + webSite;
System.out.println(result);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(BuilderMedia.class);
}
}

应用优点：

建造模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表

象是由产品自身来决定的；而在建造模式中则是“外部化”为由建造者来负责。这样定义一个新的具体建造者角色就可以改变产品的内部表象，符合“开闭原则”。

建造模式使得客户不需要知道太多产品内部的细节。它将复杂对象的组建和表示方式封

装在一个具体的建造角色中，而且由指导者来协调建造者角色来得到具体的产品实例。

每一个具体建造者角色是毫无关系的。

建造模式可以对复杂产品的创建进行更加精细的控制。产品的组成是由指导者角色调用

具体建造者角色来逐步完成的，所以比起其它创建型模式能更好的反映产品的构造过程。

扩展：

建造模式中很可能要用到组成成品的各种组件类，对于这些类的创建可以考虑使用工厂

方法或者原型模式来实现，在必要的时候也可以加上单例模式来控制类实例的产生。但是要

坚持一个大前提就是要使引入的模式给你的系统带来好处，而不是臃肿的结构。