java设计模式（3）：抽象工厂模式（Abstract Factory）

最新推荐文章于 2022-09-18 08:34:01 发布

lwj0310

最新推荐文章于 2022-09-18 08:34:01 发布

阅读量613

点赞数

分类专栏： java设计模式文章标签： java设计模式

java设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

概述

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。

意图

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

模型图

逻辑模型：

物理模型：

实现要点

抽象工厂将产品对象的创建延迟到它的具体工厂的子类。
如果没有应对“多系列对象创建”的需求变化，则没有必要使用抽象工厂模式，这时候使用简单的静态工厂完全可以。
系列对象指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖，“道路”与“地道”的依赖。
抽象工厂模式经常和工厂方法模式共同组合来应对“对象创建”的需求变化。
通常在运行时刻创建一个具体工厂类的实例，这一具体工厂的创建具有特定实现的产品对象，为创建不同的产品对象，客户应使用不同的具体工厂。
把工厂作为单件，一个应用中一般每个产品系列只需一个具体工厂的实例，因此，工厂通常最好实现为一个单件模式。
创建产品，抽象工厂仅声明一个创建产品的接口，真正创建产品是由具体产品类创建的，最通常的一个办法是为每一个产品定义一个工厂方法，一个具体的工厂将为每个产品重定义该工厂方法以指定产品，虽然这样的实现很简单，但它确要求每个产品系列都要有一个新的具体工厂子类，即使这些产品系列的差别很小。

优点

分离了具体的类。抽象工厂模式帮助你控制一个应用创建的对象的类，因为一个工厂封装创建产品对象的责任和过程。它将客户和类的实现分离，客户通过他们的抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。
它使得易于交换产品系列。一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。
它有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。

缺点

难以支持新种类的产品。难以扩展抽象工厂以生产新种类的产品。这是因为抽象工厂几口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将涉及抽象工厂类及其所有子类的改变。

适用性

在以下情况下应当考虑使用抽象工厂模式：

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
这个系统有多于一个的产品族，而系统只消费其中某一产品族。
同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

应用场景

支持多种观感标准的用户界面工具箱（Kit）。
游戏开发中的多风格系列场景，比如道路，房屋，管道等。
……

代码如下：

抽象产品角色（我们定义了一个打印机）

[java]view plaincopyprint? 
    
 public abstract class Printer  
 {  
     public abstract void out();  
       
     public abstract void getData(String msg);  
 }  

抽象工厂角色

[java]view plaincopyprint? 
    
 public interface PrinterFactory  
 {  
     public Printer getPrinter(String type);  
 }  

具体工厂角色（我们定义4个具体工厂，一个是高速打印机工厂，一个是普通打印机工厂，一个是戴尔打印机工厂，一个是惠普打印机工厂）

[java]view plaincopyprint? 
    
 /* 
  * a、生产高速打印机的工厂 
  * b、可以是戴尔，也可以是惠普 
  */  
 public class BetterPrinterFactory implements PrinterFactory  
 {  
     public Printer getPrinter(String type)  
     {  
         if(type.equals("dell"))  
         {  
             return new DellBetterPrinter();  
         }  
         else if(type.equals("hp"))  
         {  
             return new HpBetterPrinter();  
         }  
         else  
         {  
             return null;  
         }  
     }  
 }  
   
 /* 
  * a、生产普通打印机的工厂 
  * b、可以是戴尔，也可以是惠普 
  */  
 public class CommonPrinterFactory implements PrinterFactory  
 {  
     public Printer getPrinter(String type)  
     {  
         if(type.equals("dell"))  
         {  
             return new DellCommonPrinter();  
         }  
         else if(type.equals("hp"))  
         {  
             return new HpCommonPrinter();  
         }  
         else  
         {  
             return null;  
         }  
     }  
 }  
   
   
 /* 
  * a、生产戴尔打印机的工厂 
  * b、可以是高速打印机，也可以是普通打印机 
  */  
 public class DellPrinterFactory implements PrinterFactory  
 {  
     public Printer getPrinter(String vendor)  
     {  
         if(vendor.equals("better"))  
         {  
             return new DellBetterPrinter();  
         }  
         else if(vendor.equals("common"))  
         {  
             return new DellCommonPrinter();  
         }  
         else  
         {  
             return null;  
         }  
     }  
 }  
   
   
 /* 
  * a、生产惠普打印机的工厂 
  * b、可以是高速打印机，也可以是普通打印机 
  */  
 public class HpPrinterFactory implements PrinterFactory  
 {  
     public Printer getPrinter(String vendor)  
     {  
         if(vendor.equals("better"))  
         {  
             return new HpBetterPrinter();  
         }  
         else if(vendor.equals("common"))  
         {  
             return new HpCommonPrinter();  
         }  
         else  
         {  
             return null;  
         }  
     }  
 }  

具体产品角色（我们定义四个产品。戴尔高速打印机，戴尔普通打印机，惠普高速打印机，惠普普通打印机）

[java]view plaincopyprint? 
    
 /** 
  * 戴尔高速打印机 
  */  
 public class DellBetterPrinter extends Printer  
 {  
     private  final int MAX_CACHE_LINE = 10;  
     private String[] printData = new String[MAX_CACHE_LINE * 2];  
       
     private int dataNum = 0;  
   
     @Override  
     public void getData(String msg)  
     {  
         if(dataNum >= MAX_CACHE_LINE * 2)  
         {  
             System.out.println("输出队列已满,添加失败");  
         }  
         else  
         {  
             printData[dataNum++] = msg;  
         }  
     }  
   
     @Override  
     public void out()  
     {  
         while(dataNum>0)  
         {  
             System.out.println("戴尔高速打印机打印: "+printData[0]);  
               
             System.arraycopy(printData,1,printData,0,--dataNum);  
         }  
     }  
 }  
   
   
 /** 
  * 戴尔普通打印机 
  */  
 public class DellCommonPrinter extends Printer  
 {  
     private  final int MAX_CACHE_LINE = 10;  
     private String[] printData = new String[MAX_CACHE_LINE];  
       
     private int dataNum = 0;  
   
     @Override  
     public void getData(String msg)  
     {  
         if(dataNum >= MAX_CACHE_LINE)  
         {  
             System.out.println("输出队列已满,添加失败");  
         }  
         else  
         {  
             printData[dataNum++] = msg;  
         }  
     }  
   
     @Override  
     public void out()  
     {  
         while(dataNum>0)  
         {  
             System.out.println("戴尔普通打印机打印: "+printData[0]);  
               
             System.arraycopy(printData,1,printData,0,--dataNum);  
         }  
   
     }  
 }  
   
   
 /** 
  * 惠普高速打印机 
  */  
 public class HpBetterPrinter extends Printer  
 {  
     private  final int MAX_CACHE_LINE = 10;  
     private String[] printData = new String[MAX_CACHE_LINE * 2];  
       
     private int dataNum = 0;  
   
     @Override  
     public void getData(String msg)  
     {  
         if(dataNum >= MAX_CACHE_LINE * 2)  
         {  
             System.out.println("输出队列已满,添加失败");  
         }  
         else  
         {  
             printData[dataNum++] = msg;  
         }  
     }  
   
     @Override  
     public void out()  
     {  
         while(dataNum>0)  
         {  
             System.out.println("惠普高速打印机打印: "+printData[0]);  
               
             System.arraycopy(printData,1,printData,0,--dataNum);  
         }  
     }  
 }  
   
   
 /** 
  * 惠普普通打印机 
  */  
 public class HpCommonPrinter extends Printer  
 {  
     private  final int MAX_CACHE_LINE = 10;  
     private String[] printData = new String[MAX_CACHE_LINE];  
       
     private int dataNum = 0;  
   
     @Override  
     public void getData(String msg)  
     {  
         if(dataNum >= MAX_CACHE_LINE)  
         {  
             System.out.println("输出队列已满,添加失败");  
         }  
         else  
         {  
             printData[dataNum++] = msg;  
         }  
     }  
   
     @Override  
     public void out()  
     {  
         while(dataNum>0)  
         {  
             System.out.println("惠普普通打印机打印: "+printData[0]);  
               
             System.arraycopy(printData,1,printData,0,--dataNum);  
         }  
     }  
 }  

制造出一个想要的工厂，去生产相对应的打印机

[java]view plaincopyprint? 
    
 /* 
  * 制造出一个想要的工厂，去生产相对应的打印机 
  */  
 public class PrinterFactoryFactory  
 {  
     public  PrinterFactory getPrintFactory(String type)  
     {  
         if(type.equals("common"))//造出一个生产普通打印机的工厂  
         {  
             return new CommonPrinterFactory();  
         }  
         else if(type.equals("better"))//造出一个生产高速打印机的工厂  
         {  
             return new BetterPrinterFactory();  
         }  
         else if(type.equals("dell"))//造出一个生产戴尔打印机的工厂  
         {  
             return new DellPrinterFactory();//造出一个生产惠普打印机的工厂  
         }  
         else if(type.equals("hp"))  
         {  
             return new HpPrinterFactory();  
         }  
         else  
         {  
             return null;  
         }  
     }  
 }  

最后是测试了，我们定义一台计算机，由它调用工厂去生产我们需要的打印机。

需要什么品牌什么类型的打印机，只需要获得生产对应类型的工厂，再由工厂生产具体的打印机。这里我们有四个类型的工厂，打个比方，1）惠普公司本部可以有个工厂，它能生产惠普品牌的普通或高速型打印机:2）戴尔公司本部也有个工厂，它能生产惠普品牌的普通或高速型打印机:3）然而也有些高低端的代工厂愿意给那些大公司生产打印机，有专门生产普通打印机的低端工厂，它可以生产惠普、戴尔型号的低端打印机；4）当然也有高端型的代工厂，给惠普、戴尔生产它们的高端型品牌。

在这里，无论我们需要什么品牌什么类型的打印机，我们要么在这个品牌的工厂拿到，要么在高端或低端代工厂拿到。

[java]view plaincopyprint? 
    
 public class Computer  
 {  
     private Printer out;  
   
     public Computer(Printer out)  
     {  
         this.out = out;  
     }  
     public void keyIn(String msg)  
     {  
         out.getData(msg);  
     }  
     public void print()  
     {  
         out.out();  
     }  
     public static void main(String[] args)  
     {  
         PrinterFactoryFactory pff = new PrinterFactoryFactory();  
         PrinterFactory of = pff.getPrintFactory("common");  
         Computer c = new Computer(of.getPrinter("hp"));  
         c.keyIn("hello");  
         c.keyIn("world");  
         c.print();  
           
         PrinterFactoryFactory pff2 = new PrinterFactoryFactory();  
         PrinterFactory of2 = pff2.getPrintFactory("hp");  
         Computer c2 = new Computer(of2.getPrinter("common"));  
         c2.keyIn("hello");  
         c2.keyIn("world");  
         c2.print();  
     }  
 }  

输出结果：

惠普普通打印机打印: hello
惠普普通打印机打印: world

总结

总之，抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，运用抽象工厂模式的关键点在于应对“多系列对象创建”的需求变化。一句话，学会了抽象工厂模式，你将理解OOP的精华：面向接口编程。

lwj0310

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java设计模式（3）：抽象工厂模式（Abstract Factory）

概述在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。意图提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。模型图
复制链接

扫一扫

专栏目录