Abstract Factory Pattern（抽象工厂模式）——莫勇鹏老师

Abstract Factory Pattern（抽象工厂模式）

抽象工厂就是一要一种关联耦合设计成一个抽象类。抽象工厂模式符合GRASP的纯虚构模式，同时取得高内聚低耦合的效果。

 

其UML类图如下：

其中的类或对象之间的关系为：

AbstractFactory（抽象工厂）：声明生成抽象产品的方法。

ConcreteFactory（具体工厂）：执行生成抽象产品的方法，生成一个具体的产品。

AbstractProduct（抽象产品）：为一种产品声明接口。

Product（具体产品）：定义具体工厂生成的具体产品的对象，实现产品接口。

Client（客户）：我们的应用程序，使用抽象产品和抽象工厂生成对象。

 

Java实例——电脑产品

 

首先，定义CPU接口：

public interface CPU {

       public StringgetCPU();

}

 

定义AMD类，实现CPU接口：

public class AMD implements CPU{

 

       @Override

       public String getCPU() {

              // TODO Auto-generated method stub

              return "Athlon XP2800+";

       }

 

}

 

定义Intel类，实现CPU接口：

public class Intel implements CPU{

 

       @Override

       public StringgetCPU() {

              // TODO Auto-generated method stub

              return "奔腾4 3.2C";

       }

 

}

 

定义硬盘接口：

public interface HardDisk {

       public StringgetSize();

}

 

定义Maxtor类，实现硬盘接口：

public class Maxtor implements HardDisk{

 

       @Override

       public StringgetSize() {

              // TODO Auto-generated method stub

              return "MaxLine Plus II 200G";

       }

 

}

 

定义WestDigit类，实现硬盘接口：

public class WestDigit implements HardDisk{

 

       @Override

       public StringgetSize() {

              // TODO Auto-generated method stub

              return "WD2500JD 250G";

       }

 

}

 

定义主板的接口，包含参数为CPU的公共方法Attach()：

public interface MainBoard {

       public voidAttach(CPU cpu) throws Exception;

}

 

主板微星MSI865PE，支持Intel的CPU：

public class MSI865PE implements MainBoard{

 

       @Override

       public voidAttach(CPU cpu) throws Exception {

              // TODO Auto-generated method stub

              if(cpu.getClass().toString().endsWith("Intel")){

                     System.out.println("MSI865PE");

              }

              else {

                     throw newException("主板MSI865PE只能配Intel的CPU");

              }

       }

 

}

 

主板微星MSIK7N2G，支持AMD的CPU：

public class MSIK7N2G implements MainBoard{

 

       @Override

       public voidAttach(CPU cpu) throws Exception {

              // TODO Auto-generated method stub

              if(cpu.getClass().toString().endsWith("AMD")){

                     System.out.println("MSIK7N2G");

              }

              else {

                     throw newException("主板MSIK7N2G只能配AMD的CPU");

              }

       }

 

}

 

定义抽象电脑工厂类：

Publicabstract classComputerFactory {

       CPU cpu;

       HardDisk hd;

       MainBoard mb;

      

       public voidshow(){

              try {

                     System.out.println(this.getClass().getName().toString()+"生产的电脑配置");

                     System.out.println("CPU:"+cpu.getCPU());

                     System.out.println("HardDisk:"+hd.getSize());

                     System.out.print("MainBoard:");

                     mb.Attach(cpu);

              } catch(Exception e) {

                     // TODO: handle exception

                     System.out.println(e.getMessage());

              }

       }

}

 

抽象电脑工厂类派生类IBM，定义其返回的系列配件产品：

public class IBM extends ComputerFactory{

       IBM()

       {

              cpu=newIntel();

              hd=newWestDigit();

              mb=newMSI865PE();

       }

}

 

抽象电脑工厂类派生类Dell，定义其返回的系列配件产品：

public class Dell extends ComputerFactory{

       Dell() {

              // TODO Auto-generated constructor stub

              cpu=new AMD();

              hd=newMaxtor();

              mb=newMSIK7N2G();

       }

}

 

客户程序调用：

public class Client {

       public static voidmain(String[] args){

              IBM ibm=new IBM();

              ibm.show();

              Dell dell=newDell();

              dell.show();

       }

}

 

输出结果为：

abstract_factory_pattern.IBM生产的电脑配置

CPU:奔腾4 3.2C

HardDisk:WD2500JD250G

MainBoard:MSI865PE

abstract_factory_pattern.Dell生产的电脑配置

CPU:Athlon XP 2800+

HardDisk:MaxLinePlus II 200G

MainBoard:MSIK7N2G

 

应用情景：

1.      系统需要屏蔽有关对象如何创建、如何组织和如何表示。

2.      系统需要由关联的多个对象来构成。

3.      有关联的多个对象需要一起应用并且它们的约束是强迫的（不可分离）。

4.      你想提供一组对象而不显示它们的实现过程，只显示它们的接口。