我们在使用简单工厂或工厂方法，createProduct()是直接返回了已完成的产品。而有些产品由好几个零部件组装而成，各个零部件单独生产，并相关联。这次我们要介绍的是生产自行车的工厂。

自行车工厂

自行车工厂的任务是：

1. 生产两个品牌系列：凤牌和凰牌的自行车
2. 生产自行车的各个系列相关零部件：车架（BikeRack），车轮（Wheel）和脚踏板（Pedal），最后组装自行车。

品牌差异

因为凤牌和凰牌自行车的定位不同，它们各自的车架，车轮和脚踏板的材料以及制作工艺是比较大的差异，所以不能统一在一个工厂生产。

很自然，我们会想到在两个工厂：FengBikePartsFactory和HuangBikePartsFactory生产。

组装所用零部件类别相同

虽然两个品牌零部件不同，但它们所用到的零部件类别规格相同，且组装方式也一样。为了规范零部件的规格和流程，我们抽象规范生产零部件的工厂接口，BikePartsFactory：

//规范零部件车架
public abstract class BikeRack {
}
//规范零部件脚踏
public abstract class Pedal {
}
//规范零部件车轮
public abstract class Wheel {
}
public abstract class BikePartsFactory {
    abstract BikeRack createRack();
    abstract Wheel createWheel();
    abstract Pedal createPedal();
}

各自工厂就可以继承BikePartsFacotry，生产各自的零部件。

凤自行车零部件工厂

凤自行车的零部件实现零部件的接口，最后由FengBikePartsFactory生产。

//实现BikeRack要求，满足自行车架规格
public class FengBikeRack extends BikeRack{}
public class FengWheel extends Wheel {}
public class FengPedal extends Pedal{}

public class FengBikePartsFactory extends BikePartsFactory{
    @Override
    BikeRack createRack() {
        return new FengBikeRack();
    }
    @Override
    Wheel createWheel() {
        return new FengWheel();
    }
    @Override
    Pedal createPedal() {
        return new FengPedal();
    }
}

凰自行车零部件工厂

同样，凰自行车零部件实现零部件的接口，最后由HuangBikePartsFactory生产。

//实现BikeRack要求，满足自行车架规格
public class HuangBikeRack extends BikeRack{}
public class HuangWheel extends Wheel {}
public class HuangPedal extends Pedal{}

public class HuangBikePartsFactory extends BikePartsFactory{
    @Override
    BikeRack createRack() {
        return new HuangBikeRack();
    }
    @Override
    Wheel createWheel() {
        return new HuangWheel();
    }
    @Override
    Pedal createPedal() {
        return new HuangPedal();
    }
}

自行车组装

简化实现中的自行车组装，组装车间只需要拿到每个品牌各自的一套零部件，就可以按标准流程组装完成。

public class BikeAssemble {
    private BikePartsFactory bikePartsFactory;
 
    public BikeAssemble(BikePartsFactory bikePartsFactory) {
        this.bikePartsFactory = bikePartsFactory;
    }
    
    public Bike create() {
        BikeRack bikeRack = bikePartsFactory.createRack();
        Wheel wheel = bikePartsFactory.createWheel();
        Pedal pedal = bikePartsFactory.createPedal();
        return new Bike(bikeRack,wheel, pedal);
    }
}

那么要生产凤自行车和凰自行车，只要告诉那个零部件工厂生产即可。

生产方式：

public static void main(String[] args) {
        //生产凤自行车
        BikeAssemble assemble = new BikeAssemble(new FengBikePartsFacotry());
        Bike fengBike = assemble.create();
        
        //生产凰自行车
        BikeAssemble assemble = new BikeAssemble(new HuangBikePartsFacotry());
        Bike huangBike = assemble.create();
 }

抽象工厂

上述生产自行车的工厂使用就是我们要介绍的设计模式：抽象工厂。

抽象工厂模式：提供一个接口，用于创建相关或者依赖对象的系列，而不需要明确指定具体类。

抽象工厂是创建型设计模式，类图如下：

AbstractFactory：抽象工厂会提供接口生成相关或者相互依赖的产品家族。

ConcreteFactory：具体化工厂，它会实现抽象工厂提供的生成产品家族接口。

ProductA：相关联家族的产品抽象，由抽象定义创建产品方法。

ConcreteProduct：具体的产品，实现抽象产品接口ProductA，并在系列的具体工厂实现创建。

Client：调用工厂，组合具体工厂创建的相关产品，创建最终产品。

抽象工厂 VS 工厂方法

1. 工厂方法只提供用一个方法，而抽象工厂提供产品家族的多个创建方法。
2. 工厂方法往往创建的是单一产品，而抽象工厂创建的是相关或者相互依赖的产品家族。