工厂模式 - 抽象工厂

跟随上一篇 工厂模式 这一篇文章我们来看看工厂方法的进阶---------抽象工厂

在看抽象工厂前，我们需要引入两个概念：

1、产品等级结构

2、产品族

我们现在有这样两个产品类型：汽车（Car）、自行车（Bike）；有两家公司：宝马（BMW）、奥迪（AUDI），每一个厂家都能够生产这两种类型的产品：BMW接口（BMWCar，BMWBike），AUDI接口（AUDICar，AUDIBike）。在这里Car是一个抽象类型，BMWCar是Car的具体实现类，AUDICar也是Car的具体实现类。因此我们就可以说AUDICar和BMWCar属于同一个产品等级。每一个工厂又可以生产所有类型的产品（BMW工厂就可以生产BMWCar和BMWBike）因此我们就可以说BMWCar，BMWBike属于同一个产品族。

工厂方法模式解决的范畴是产品等级（上一篇文章的Product（CarProduct，BikeProduct））；抽象工厂模式解决的范畴是产品族（BMWCar，BMWBike）；

首先，我们先抽象出一个Car，一个Bike：

package com.abstractproduct;

public abstract class Bike {
    public abstract void speak();
}

package com.abstractproduct;

public abstract class Car {
    public abstract void speak();
}

接下来需要写一个工厂接口：

package com.factorymode;

import com.abstractproduct.Bike;
import com.abstractproduct.Car;

public interface AbstractFactory {

    public Car produceCar();

    public Bike produceBike();
}

从上面的接口可以看出，一个工厂可以同时生产Car类型和Bike类型的产品；

我们这里有两家工厂，一个BMW，一个AUDI，因此我们需要创建出来不同工厂的具体的产品，他们分别继承自（Car，Bike）

BMWCar

package com.entiryproduct;

import com.abstractproduct.Car;

public class BMWCar extends Car {
    @Override
    public void speak() {
        // TODO Auto-generated method stub
        System.out.println("i am BMW car");
    }
}

BMWBike

package com.entiryproduct;

import com.abstractproduct.Bike;

public class BMWBike extends Bike {
    @Override
    public void speak() {
        // TODO Auto-generated method stub
        System.out.println("i am BMW bike");
    }
}

AUDICar

package com.entiryproduct;

import com.abstractproduct.Car;

public class AUDICar extends Car {
    @Override
    public void speak() {
        // TODO Auto-generated method stub
        System.out.println("i am AUDI car");
    }
}

AUDIBike

package com.entiryproduct;

import com.abstractproduct.Bike;

public class AUDIBike extends Bike {
    @Override
    public void speak() {
        // TODO Auto-generated method stub
        System.out.println("i am AUDI bike");
    }
}

接下来就是具体创建两个不同的工厂了，它们都实现了AbstractFactory接口

BMWFactory

package com.entityfactory;

import com.abstractproduct.Bike;
import com.abstractproduct.Car;
import com.entiryproduct.BMWBike;
import com.entiryproduct.BMWCar;
import com.factorymode.AbstractFactory;

public class BMWFactory implements AbstractFactory{

    @Override
    public Car produceCar() {
        // TODO Auto-generated method stub
        return new BMWCar();
    }

    @Override
    public Bike produceBike() {
        // TODO Auto-generated method stub
        return new BMWBike();
    }
}

AUDIFacroty

package com.entityfactory;

import com.abstractproduct.Bike;
import com.abstractproduct.Car;
import com.entiryproduct.AUDIBike;
import com.entiryproduct.AUDICar;
import com.factorymode.AbstractFactory;

public class AUDIFactory implements AbstractFactory{

    @Override
    public Car produceCar() {
        // TODO Auto-generated method stub
        return new AUDICar();
    }

    @Override
    public Bike produceBike() {
        // TODO Auto-generated method stub
        return new AUDIBike();
    }
}

在具体的工厂中，都实现了produceCar和prodeceBike方法用来生产实际的产品。


我们写一个测试类来验证一下：

package com.test;

import com.abstractproduct.Bike;
import com.abstractproduct.Car;
import com.entityfactory.BMWFactory;
import com.factorymode.AbstractFactory;

public class Main {
    public static void main(String[] args) {

        // --------------抽象工厂模式
        AbstractFactory abstractFactory = new BMWFactory();
        Car productCar = abstractFactory.produceCar();
        productCar.speak();

        Bike productBike = abstractFactory.produceBike();
        productBike.speak();
    }
}

这里我们实例化了一个BMW工厂（BMWFactory），它可以同时生产出两种产品（Car和Bike），运行一下，结果如下：

i am BMW car
i am BMW bike

可以看到，BMW工厂中，生产出来的产品是BMW car，和BMW bike。同一家工厂可以生产不同类型、但是属于同一个产品族的产品（BMWCar，BMWBike）。

到此结束~  

分析这个，一开始在概念上走上了误区，把自己绕进去了，后来看了别人的文章才理清楚这个关系，主要还是在理解 产品等级结构，和产品族的概念上，只要理解了这两个概念，就能很顺利的理解抽象工厂的内容。看来还是自己的水平有限，技术知识储备提升迫在眉睫。

加油！！！