抽象工厂模式

　　工厂方法模式不清楚可以先查看上一篇博文工厂方法模式，这里先看一个工厂方法模式的例子：

抽象产品类（ 汽车总称）：

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.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类）。

　　

　　抽象工厂模式相对于工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品，比如白色奥迪，黑色奥迪，红色奥迪）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。