建造者模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，需要应用一个设计模式，建造者模式，又叫生成器模式。建造者模式可以将一个产品的内部表象与产品的生成过程分割开，从而可以使一个建造过程生成具有不同的内部表象的产品对象。如果用了建造者模式，用户只需指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不要知道了。
建造者模式（Builder），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。[DP]
建造小人
用程序画一个小人，要求有头、身体、两手、两脚。
首先，定义一个抽象的建造人的类，把这个过程稳定住，不让任何人遗忘当中的任何一步。
public abstract class PersonBuilder {
protected Graphics g;
public PersonBuilder(Graphics g) {
this.g = g;
}
public abstract void buildHead();
public abstract void buildBody();
public abstract void buildArmLeft();
public abstract void buildArmRight();
public abstract void buildLegLeft();
public abstract void buildLegRight();
}
再建造一个瘦的小人，让这个类去继承抽象类，必须重写抽象方法
public class PersonThinBuilder extends PersonBuilder {
public PersonThinBuilder(Graphics g) {
super(g);
}
@Override
public void buildHead() {
g.drawOval(50, 20, 30, 30);
}
@Override
public void buildBody() {
g.drawRect(60,50,10,50);
}
@Override
public void buildArmLeft() {
g.drawLine(60,50,40,100);
}
@Override
public void buildArmRight() {
g.drawLine(70,50,90,100);
}
@Override
public void buildLegLeft() {
g.drawLine(60,100,45,150);
}
@Override
public void buildLegRight() {
g.drawLine(70,100,85,150);
}
}
其他类型如高个子、矮个子等都是类似的代码去实现这个类。
还需要一个指挥者（Director），用它来控制建造过程，也用来隔离用户与建造过程的关联。
public class PersonDirector {
private PersonBuilder pb;
/**
* 用户告诉指挥者，需要什么样的小人
* @param pb
*/
public PersonDirector(PersonBuilder pb){
this.pb = pb;
}
/**
* 根据用户的选择建造小人
*/
public void createPerson(){
pb.buildHead();
pb.buildBody();
pb.buildArmLeft();
pb.buildArmRight();
pb.buildLegLeft();
pb.buildLegRight();
}
}
PersonDirector类的目的就是根据用户的选择来一步一步建造小人，而建造的过程在指挥者这里完成，用户就不需要知道，而且，由于这个过程每一步都是一定要做的，就不会少画一只手的问题出现。
测试代码
public class PersonTest {
public static void main(String[] args){
JFrame newFrame=new JFrame("person");
//定义JFrame关闭时的操作（必需），有效避免不能关闭后台当前框体进程的问题
newFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
newFrame.setSize(400, 400);
newFrame.setLocation(200, 200);
newFrame.setVisible(true);
MyPanel jPanel = new MyPanel();
newFrame.add(jPanel);
jPanel.display();
}
}
public class MyPanel extends JPanel {
public void display() {
this.repaint();
}
/**
* repaint方法会调用paint方法，并自动获得Graphics对像
* 然后可以用该对像进行2D画图
* 注：该方法是重写了JPanel的paint方法
*/
@Override
public void paint(Graphics g) {
g.setColor(Color.red);
PersonThinBuilder pb = new PersonThinBuilder(g);
PersonDirector personDirector = new PersonDirector(pb);
personDirector.createPerson();
}
}
运行效果
图片.png
如果建造人的步骤需要细化，比如人的五官，手的上臂、前臂和手掌，大腿小腿等。这些细节如果是每个具体的小人都需要构建的，就需要加到抽象类里，反之，就不需要。其实建造者模式是逐步建造产品的，所以建造者的Builder类里的那些建造方法必须要足够普遍，以便为各种类型的具体建造者构造。
建造者模式（Builder）结构图
图片.png
建造者模式主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序是稳定的，但对象内部的构建通常面临着复杂的变化。
建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。
建造者模式基本代码
Product类--产品类，由多个部件组成。
public class Product {
List<String> parts = new ArrayList<>();
/**
* 添加产品部件
* @param part
*/
public void add(String part){
parts.add(part);
}
/**
* 列举所有的产品部件
*/
public void show(){
print("产品创建------");
for(String part : parts){
print(part);
}
}
}
Builder类--抽象建造者类，确定产品由两个部件PartA和PartB组成，并声明一个得到产品建造后结果的方法GetResult。
public abstract class Builder {
public abstract void buildPartA();
public abstract void buildPartB();
public abstract Product getResult();
}
ConcreteBuilder1类--具体建造者类
public class ConcreteBuilder1 extends Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.add("部件A");
}
@Override
public void buildPartB() {
product.add("部件B");
}
@Override
public Product getResult() {
return product;
}
}
ConcreteBuilder2类--具体建造者类
public class ConcreteBuilder2 extends Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.add("部件X");
}
@Override
public void buildPartB() {
product.add("部件Y");
}
@Override
public Product getResult() {
return product;
}
}
Director类--指挥者类
public class Director {
public void construct(Builder builder){
builder.buildPartA();
builder.buildPartB();
}
}
测试代码
public class Test {
public static void main(String[] args){
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();
director.construct(b1);
Product result = b1.getResult();
result.show();
director.construct(b2);
Product result1 = b2.getResult();
result1.show();
}
}
运行结果
图片.png
建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时使用的模式。
网友评论