设计模式课时十四------建造者（生成器）模式

生成器模式

/**
 * 生成器模式
 * 生成器：BenzBuilder
 * 制造者：Producer
 */
package Abstract.builder;

import java.util.ArrayList;
import java.util.List;

class Body
{

}
class Engine{}
class Wheel
{
    private String name ;
    public Wheel(String Name)
    {
        this.name = Name;
    }
}
class Car
{
    private Body body;
    private Engine engine;
    private List<Wheel> list;
    public void addBody(Body b)
    {
        this.body = b;
    }
    public void addEngine(Engine e)
    {
        this.engine = e;
    }
    public void addWheel(Wheel w )
    {
        if (list == null)
        {
            list = new ArrayList<Wheel>();
        }
        list.add(w);
    }
    public void ShowMe()
    {
        if (body!=null && engine!=null && list!=null)
        {
            System.out.println("你的汽车。。。。");
        }
    }
}
abstract class CarBuilder
{
    public abstract void buildBody();
    public abstract void buildEngine();
    public abstract void buildWheel(String name);
}
class BenzBuilder extends CarBuilder
{
    private Car car ;
    public BenzBuilder(Car c)
    {
        this.car = c;
    }
    @Override
    public void buildBody()
    {
        car.addBody(new Body());
    }
    @Override
    public void buildEngine() {
        car.addEngine(new Engine());
    }
    @Override
    public void buildWheel(String name) {
        car.addWheel(new Wheel(name));
    }
    public Car getCar()
    {
        return car;
    }
}
// 此类可以做抽象类的实现，从而满足不同轮子、车身的产品-----火车、货车、飞机等等、、、
class Producer
{
    private CarBuilder builder;
    public Producer(CarBuilder b)
    {
        this.builder = b;
    }
    public void construct()
    {
        builder.buildBody();
        builder.buildEngine();
        builder.buildWheel("轮子1");
        builder.buildWheel("轮子2");
        builder.buildWheel("轮子3");
        builder.buildWheel("轮子4");
    }
}
public class Demo {
    public static void main(String[] args) {
        BenzBuilder builder = new BenzBuilder(new Car());
        Producer producer = new Producer(builder);
        producer.construct();
        Car car = builder.getCar();
        car.ShowMe();
    }
}

我们把Car抽象化，然后具体Benz从Car继承，-------典型抽象工厂模式

工厂模式 和 生成器模式的区别

单一产品-- 静态简单工厂模式
不同产品族— 工厂方法模式
不同产品档次 抽象工厂模式

由此可见，
工厂模式 ：解决一种或多种产品的系列化生成，注重整体创建产品细节差异，
生成器模式 ：关注的是复杂产品的创建细节，如何一步一步完成复杂产品的部件创建和组装的过程