抽象模式

本文出自 “蚂蚁” 博客，请务必保留此出处http://haolloyin.blog.51cto.com/1177454/332802

抽象工厂模式（ Abstract Factory ）：为创建一组相关或者互相依赖的对象提供一个接口，而无需指定它们对应的具体类。

通用类图如下：

例如，我们现在有两种产品 A和B，而产品A和B分别都有两个厂商1和2进行生产，在这里我们把不同的厂商1、厂商2理解为牌子1和牌子2，那么厂商1就生产A1、B1，厂商2生产A2、B2。

此时，不同的厂商肯定要生产自己的产品（如A1、B1），每个厂商都有自己的一系列产品，这就与上面抽象工厂模式的描述类似了。

该例子的类图如下：

具体代码实现如下：

//定义不同的产品之间的一定具备的标准，用 interface实现 
//其中的method()方法可看作提取出不同产品的共性，如手机都有类似的功能 
interface IProductA{ 
   public  void method(); 
} 

interface IProductB{ 
   public  void method(); 
} 

//实现了产品标准实现的一系列具体产品 
//由于已经设计好A1由厂商1生产，故以下输出代码有“厂商x” 
class ProductA1  implements IProductA{ 
   public  void method() { 
    System.out.println( "厂商1    生产ProductA1 ..."); 
  } 
} 

class ProductA2  implements IProductA{ 
   public  void method() { 
    System.out.println( "厂商2    生产ProductA2 ..."); 
  } 
} 

class ProductB1  implements IProductB{ 
   public  void method() { 
    System.out.println( "厂商1    生产ProductB1 ..."); 
  } 
} 

class ProductB2  implements IProductB{ 
   public  void method() { 
    System.out.println( "厂商2    生产ProductB2 ..."); 
  } 
} 

//每一种牌子的产品生产工厂，即不同的厂商负责自己牌子产品的生产 
abstract  class Factory1{ 
   abstract IProductA getProductA1(); 
   abstract IProductB getProductB1(); 
} 

abstract  class Factory2{ 
   abstract IProductA getProductA2(); 
   abstract IProductB getProductB2(); 
} 

//具体的工厂用来生产相关的产品 
class ConcreteFactory1  extends Factory1{ 
   public IProductA getProductA1() { 
     return  new ProductA1(); 
  } 
   public IProductB getProductB1() { 
     return  new ProductB1(); 
  } 
} 

class ConcreteFactoryB  extends Factory2{ 
   public IProductA getProductA2() { 
     return  new ProductA2(); 
  } 
   public IProductB getProductB2() { 
     return  new ProductB2(); 
  } 
} 

//测试类 
public  class Client { 
   public  static  void main(String[] args) { 
     //厂商1负责生产产品A1、B1 
    Factory1 factory1 =  new ConcreteFactory1(); 
    IProductA productA1 = factory1.getProductA1(); 
    IProductB productB1 = factory1.getProductB1(); 
     
    productA1.method(); 
    productB1.method(); 
     
     //厂商2负责生产产品A2、B2 
    Factory2 factory2 =  new ConcreteFactoryB(); 
    IProductA productA2 = factory2.getProductA2(); 
    IProductB productB2 = factory2.getProductB2(); 
     
    productA2.method(); 
    productB2.method(); 
  } 
}

运行结果：

厂商1  生产ProductA1 ... 厂商1  生产ProductB1 ... 厂商2  生产ProductA2 ... 厂商2  生产ProductB2 ...

 

其实，上例中本来可以不用到了两个抽象工厂，只剩一个也可，但是这样子与我们现实生活中不同厂商各自生产自己的产品有点不同，所以就将其分开为两个了，也就是将两个厂商完全地分离开。

由上面类图可以知道，一旦任何一个厂商开发出了产品C的话，那么这个厂商肯定需要扩展自己的工厂来投入到C产品的生产中，那么此时工厂1和工厂2就需要进行一定的改变了，这很明显不符合开闭原则。