java中23种设计模式之3-抽象工厂模式（abstract factory pattern）

抽象工厂模式的定义：

Provide an interface for creating families of related or dependent objects without specifying their concrete classes。 为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。

 

不同于工厂模式关于于产品等级，抽象工厂模式关注于产品族。

以生产球类体育用品为例： 产品为球，产品等级也就是产品种类分为足球和篮球，产品族分为NIKE牌球和ADIDAS牌球.

 

具体来说产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的，形成一个二维的坐标系，水平坐标是产品等级结构，纵坐标是产品族。叫做相图。

当有多个不同的等级结构的产品时，如果使用工厂方法模式就势必要使用多个独立的工厂等级结构来对付这些产品的等级结构。如果这些产品等级结构是平行的，会导致多个平行的工厂等级结构。

抽象工厂模式使用同一个 工厂等级结构负责这些不同产品等级结构产品对象的创建。

对于每一个产品族，都有一个具体工厂。而每一个具体工厂创建属于同一个产品族，但是分属于不同等级结构的产品。

通过引进抽象工厂模式，可以处理具有相同（或者相似）等级结构的多个产品族中的产品对象的创建问题。

由于每个具体工厂角色都需要负责两个不同等级结构的产品对象的创建，因此每个工厂角色都需要提供两个工厂方法，分别用于创建两个等级结构的产品。既然每个具体工厂角色都需要实现这两个工厂方法，所以具有一般性，不妨抽象出来，移动到抽象工厂角色中加以声明。

 

抽象工厂模式的优点：

　　创建对象不用考虑具体的产品类，对象的创建交由工厂类去创建

　　有利于产品的一致性

抽象工厂模式的缺点：

　　产品等级也就是产品种类扩展非常困难，以本例来说，产品等级中需要增加一个产品比如排球，就要修改所有工厂角色，每个工厂都要增加方法对排球的支持。

　　产品族的扩展相对容易，比如扩展一个匹克牌的产品族（这个比起NIKE,阿迪好像太弱了，权当支持国产），只需要增加匹克的工厂类就行了。

　　

/*****************product****************************/
interface IBall
{
void Ball();
}

abstract class FootBall implements IBall
{
public void Ball()
{
System.out.println("this is a FootBall");
}
}

abstract class BasketBall implements IBall
{
public void Ball()
{
System.out.println("this is a BasketBall");
}
}

class NikeFootBall extends FootBall
{
public void Ball()
{
System.out.println("this is a NikeFootBall");
}
}

class NikeBasketBall extends BasketBall
{
public void Ball()
{
System.out.println("this is a NikeBasketBall");
}
}

class AdidasFootBall extends FootBall
{
public void Ball()
{
System.out.println("this is a AdidasFootBall");
}
}

class AdidasBasketBall extends FootBall
{
public void Ball()
{
System.out.println("this is a AdidasBasketBall");
}
}

enum BallEnum
{
NIKE_FOOTBALL("NikeFootBall"),
NIKE_BASKETBALL("NikeBasketBall"),
ADIDAS_FOOTBALL("AdidasFootBall"),
ADIDAS_BASKETBALL("AdidasBasketBall");

private String value="";
private BallEnum(String value)
{
this.value=value;
}
public String getValue()
{
return this.value;
}
}
/***********************factory************************************/
interface IFactory
{
IBall makeFootBall();
IBall makeBasketBall();
}

abstract class BallFactory implements IFactory
{
public IBall makeBall(BallEnum aBallEnum)
{
IBall aIBall=null;
if(!aBallEnum.getValue().equals(""))
{
try
{
aIBall=(IBall)Class.forName(aBallEnum.getValue()).newInstance();
}
catch(Exception e)
{
e.printStackTrace();
}
}
return aIBall;
}
}

class NikeBallFactory extends BallFactory
{
public IBall makeFootBall()
{
return super.makeBall(BallEnum.NIKE_FOOTBALL);
}
public IBall makeBasketBall()
{
return super.makeBall(BallEnum.NIKE_BASKETBALL);
}
}

class AdidasBallFactory extends BallFactory
{
public IBall makeFootBall()
{
return super.makeBall(BallEnum.ADIDAS_FOOTBALL);
}
public IBall makeBasketBall()
{
return super.makeBall(BallEnum.ADIDAS_BASKETBALL);
}
}

public class AbstractFactoryPatternTest{
public static void main(String[] args)
{
IFactory aIFactory = new NikeBallFactory();
IBall aNikeFootBall=aIFactory.makeFootBall();
aNikeFootBall.Ball();
IBall aNikeBasketBall=aIFactory.makeBasketBall();
aNikeBasketBall.Ball();

aIFactory = new AdidasBallFactory();
IBall aAdidasFootBall=aIFactory.makeFootBall();
aAdidasFootBall.Ball();
IBall aAdidasBasketBall=aIFactory.makeBasketBall();
aAdidasBasketBall.Ball();
}
}

 /////////////////////////

输出结果:

this is a NikeFootBall
this is a NikeBasketBall
this is a AdidasFootBall
this is a AdidasBasketBall