抽象工厂模式

　　工厂方法模式不清楚可以先查看上一篇博文工厂方法模式，这里先看一个工厂方法模式的例子：
抽象产品类（ 汽车总称）：

public interface Car
{
        //获取车的品牌
        public void getCarType();
        // 对车进行喷漆
        public abstract void paint();
}

具体产品类（奥迪）：

public class AudiCar implements Car
{

    @Override
    public void getCarType()
    {
        System.out.println("车的品牌为奥迪");

    }

    @Override
    public void paint()
    {
        System.out.println("对车喷奥迪专用漆");

    }

}

具体产品类（奔驰）：

public class BenzCar implements Car
{

    @Override
    public void getCarType()
    {
        System.out.println("车的品牌为奔驰");

    }

    @Override
    public void paint()
    {
        System.out.println("对车喷奔驰专用漆");

    }

}

具体产品类（保时捷）：

public class PorscheCar implements Car
{

    @Override
    public void getCarType()
    {
        System.out.println("车的品牌为保时捷");

    }

    @Override
    public void paint()
    {
        System.out.println("对车喷保时捷专用漆");

    }

}

抽象工厂类（AbstractCarFatory）：

public abstract class AbstractCarFatory
{
    public abstract <T extends Car> T createCar(Class<T> cl);
}

具体工厂类（CarFactory ）：

public class CarFactory extends AbstractCarFatory
{

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Car> T createCar(Class<T> cl)
    {
        // TODO Auto-generated method stub
        Car  car = null;
        try{
            car = (T)Class.forName(cl.getName()).newInstance();
        }catch(Exception e)
        {
            e.printStackTrace();
        }
        return (T)car;
    }

}

场景类（Worker）：

public class Worker
{
    public static void main(String[] args)
    {
        //汽车加工厂
        AbstractCarFatory  carFatory  = new CarFactory();
        //开始造奥迪
        System.out.println("=============开始造奥迪===============");
        AudiCar audiCar  = carFatory.createCar(AudiCar.class);
        audiCar.getCarType();
        audiCar.paint();
        //开始造奔驰
        System.out.println("=============开始造奔驰===============");
        BenzCar benziCar  = carFatory.createCar(BenzCar.class);
        benziCar.getCarType();
        benziCar.paint();
        //开始造保时捷
        System.out.println("=============开始造保时捷===============");
        PorscheCar porscheCar  = carFatory.createCar(PorscheCar.class);
        porscheCar.getCarType();
        porscheCar.paint();
    }
}

车的生产流程执行结果：

=============开始造奥迪===============
车的品牌为奥迪
对车喷奥迪专用漆
=============开始造奔驰===============
车的品牌为奔驰
对车喷奔驰专用漆
=============开始造保时捷===============
车的品牌为保时捷
对车喷保时捷专用漆

假设现在业务发生变化，需要生产不同颜色的车，此时我们需要进行改造，代码如下：

汽车总类（Car类）：

public interface Car
{
        //获取车的品牌
        public void getCarType();
        // 对车进行喷漆
        public void paint();
        //喷漆的颜色
        public void getColor();
}

抽象汽车类（Audi，Benz，Porsche下面都有白色，黑色，红色之分，所以把Audi，Benz，Porsche抽象出来）

public abstract class AbstractBenzCar implements Car
{
    @Override
    public void getCarType()
    {
        System.out.println("车的品牌为奔驰");

    }

    @Override
    public void paint()
    {
        System.out.println("对车喷奔驰专用漆");

    }
}

public abstract class AbstractAudiCar implements Car
{
    @Override
    public void getCarType()
    {
        System.out.println("车的品牌为奥迪");

    }

    @Override
    public void paint()
    {
        System.out.println("对车喷奥迪专用漆");

    }
}

抽象汽车工厂（CarFactory）

public interface CarFactory
{
        //生产黑色汽车
        public Car creatRedCar();
        //生产白色汽车
        public Car creatWihteCar();
        //生产黑色汽车
        public Car creaBlackCar();
}

具体汽车工厂类（audi汽车工厂）

public class AudiFactory implements CarFactory
{
    //生产红色Audi
    @Override
    public Car creatRedCar()
    {
        // TODO Auto-generated method stub
        return new RedAudiCar();
    }
    //生产白色Audi
    @Override
    public Car creatWihteCar()
    {
        // TODO Auto-generated method stub
        return new WhiteAudiCar();
    }
    //生产黑色Audi
    @Override
    public Car creaBlackCar()
    {
        // TODO Auto-generated method stub
        return new BlackAudiCar();
    }

}

具体汽车工厂类（Benz汽车工厂）

public class BenzFactory implements CarFactory
{
    //生产红色Audi
    @Override
    public Car creatRedCar()
    {
        // TODO Auto-generated method stub
        return new RedBenzCar();
    }
    //生产白色Audi
    @Override
    public Car creatWihteCar()
    {
        // TODO Auto-generated method stub
        return new WhiteBenzCar();
    }
    //生产黑色Audi
    @Override
    public Car creaBlackCar()
    {
        // TODO Auto-generated method stub
        return new BlackBenzCar();
    }

}

保时捷工厂与上述工厂类似，不在赘述。
具体的产品类（白色奥迪）：

public class WhiteAudiCar extends AbstractAudiCar
{

    @Override
    public void getColor()
    {
        System.out.println("白色奥迪");
    }
}

具体的产品类（黑色奥迪）：

public class BlackAudiCar extends AbstractAudiCar
{

    @Override
    public void getColor()
    {
        System.out.println("黑色奥迪");

    }
}

具体的产品类（红色奥迪）：

public class RedAudiCar extends AbstractAudiCar
{

    @Override
    public void getColor()
    {
        System.out.println("红色奥迪");

    }
}

还有白色、红色、黑色的奔驰，保时捷汽车与奥迪类似这里不在列出代码。

场景类：

public class Worker
{
    public static void main(String[] args)
    {
        //奥迪生产线
        AudiFactory audiFactory = new AudiFactory();
        //奔驰生产线
        BenzFactory benzFactory = new BenzFactory();
        //保时捷生产线
        PorscheFactory porscheFactory = new PorscheFactory();
        //生产黑色audi
        System.out.println("===========生产黑色audi===========");
        Car blackAudi = audiFactory.creaBlackCar();
        blackAudi.getCarType();
        blackAudi.paint();
        blackAudi.getColor();
        System.out.println("===========生产白色audi===========");
        Car whiteAudi =audiFactory.creatWihteCar();
        whiteAudi.getCarType();
        whiteAudi.paint();
        whiteAudi.getColor();
        System.out.println("===========生产红色audi===========");
        Car redAudi =audiFactory.creatRedCar();
        redAudi.getCarType();
        redAudi.paint();
        redAudi.getColor();
        System.out.println("===========生产黑色benz===========");
        Car blackBenz = benzFactory.creaBlackCar();
        blackBenz.getCarType();
        blackBenz.paint();
        blackBenz.getColor();
        System.out.println("===========生产白色benz===========");
        Car whiteBenz =benzFactory.creatWihteCar();
        whiteBenz.getCarType();
        whiteBenz.paint();
        whiteBenz.getColor();
        System.out.println("===========生产红色benz===========");
        Car redBenz =benzFactory.creatRedCar();
        redBenz.getCarType();
        redBenz.paint();
        redBenz.getColor();
    }
}

执行结果为：

===========生产黑色audi===========
车的品牌为奥迪
对车喷奥迪专用漆
黑色奥迪
===========生产白色audi===========
车的品牌为奥迪
对车喷奥迪专用漆
白色奥迪
===========生产红色audi===========
车的品牌为奥迪
对车喷奥迪专用漆
红色奥迪
===========生产黑色benz===========
车的品牌为奔驰
对车喷奔驰专用漆
白色奔驰
===========生产白色benz===========
车的品牌为奔驰
对车喷奔驰专用漆
白色奔驰
===========生产红色benz===========
车的品牌为奔驰
对车喷奔驰专用漆
红色奔驰

这样我们就生产出了不同颜色的汽车。

　　上面描述的就是抽象工厂模式，抽象工厂模式是一种常用的模式，其定义如下：Provide an interface for creating families of related or dependent objects without specifying their concrete class.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类）。
　　
　　抽象工厂模式相对于工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品，比如白色奥迪，黑色奥迪，红色奥迪）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。