设计模式七—————建造者模式

建造者模式定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式初步理解：建造者模式是用来创建复杂对象的，这个对象内部可能会有很多其他很多父类对象的引用。在创建这个复杂的对象时，就要给这些引用赋值。因此产生一个build类，内部是给这些引用赋值。由于这些引用可以指向很多派生类，因此复杂对象会千变万化。根据客户端的需求将复杂对象的引用指向不同的派生类。因此有必要将build设置为抽象类，其不同的实现类将引用指向不同的派生类。
code…

---

先来看一个简单的例子，复杂对象的内部是一个Arraylist，不同的建造类添加的内容不同。 抽象的Build：

public abstract class Build {
	  protected Product product=new Product();//先实例对象
	  public abstract void buildPartA();//开始装配对象
	  public abstract void buildPartB();
	  public  Product getProduct()//返回对象
	  {
	      return product;
	  }
}

Build的实现类：

public class ConcreteBuild1 extends Build {
    @Override public void buildPartA() {
        product.add("添加部件1");
    }
    @Override public void buildPartB() {
        product.add("添加部件2");
    }
}

复杂类：

public class Product {
    private ArrayList<String> arrayList=new ArrayList<>();
    public Product() {
        System.out.println("部件主体被生产");
    }
    public void add(String string)
    {
        arrayList.add(string);
    }
    public void show()
    {
        Iterator it=arrayList.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

指挥者，用来指挥建造者进行建造工作，因为建造过程有一定的顺序。

public class Director {
    public Director(Build build)//用基类类型来接受形参
    {
        build.buildPartA();//调用建造的方法
        build.buildPartB();
    }
}

main方法：

public class Main {
    public static void main(String[] args) {
        Build build=new ConcreteBuild1();
        Director director=new Director(build);
        Product product=build.getProduct();
        product.show();
    }
}

下来看一个实际一点的例子，创建汽车类。汽车类中有发动机类和轮胎类的引用。建造汽车时分别创建好发动机类和轮胎类。然后进行转配。最后返回汽车类。
先来看汽车类的引用变量：

    private Power power;//发动机类
    private Wheel wheel;//轮胎类

因为轮胎和发动机的种类都有很多，因此有必要将Power和Wheel设置为抽象类，其实现类是具体品牌Power或Wheel。

public abstract class Power {
}

public abstract class Wheel {
}

public class BMWPower  extends Power{
    @Override  public String toString(){
        return "BMW的发动机";
    }
}

public class BYDWheel extends Wheel {
    @Override public String toString() {
        return "BYD的轮子";
    }
}

这里只写一个品牌的。
接下来是建造类：

public abstract class Build {
    private Car car=new Car();
    public abstract Power createPower();//建造发动机
    public abstract Wheel createWheel();//建造轮胎
    public Car getCar()
    {
        return car;
    }
}

具体的建造某种品牌的建造类：

public class concreteBuild extends Build{
    @Override public Power createPower() {
        return new BMWPower();
    }

    @Override public Wheel createWheel() {
        return new BYDWheel();
    }
}

指挥者进行装配：

public class Director {
    public Director(Build build)
    {
        Car car=build.getCar();
        car.setPower(build.createPower());
        car.setWheel(build.createWheel());
    }
}

main方法：

public class Main {
    public static void main(String[] args) {
        Build build=new concreteBuild();//这个build是用来建造BMW的power和BYD的Wheel
        Director director=new Director(build);
        Car car=build.getCar();
        System.out.println(car);
    }
}

总结：汽车的轮子和发动机会有很多种类，建造者负责建造具体品牌的轮子和发动机。建造好之后将这个建造者交给指挥者，指挥者负责按照一定流程来组装汽车。最后将建造好的汽车返回。对于客户端来说，建造者模式隐蔽了具体的建造过程和装配过程。用户只需要给指挥者说明需要什么样的组件即可。

---

建造者模式的使用场景：主要用于创建一些复杂的对象，这些对象内部建造的顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。建造者模式是在当前创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。

上一篇

---The End---

下一篇