您的位置: 首页  >  文章  >  设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

分类: 文章 • 2024-01-03 12:11:40

http://ichennan.com/2016/08/09/DesignPattern.html    http://blog.csdn.net/liruikqn/article/details/12888511


抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

类型：创建类模式


抽象工厂模式与工厂方法模式的区别

        抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。



设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

可以看到产品族包括ProductA和ProductB两种产品，每个具体工厂都能生产这两种产品，只是ConcreteFactory1生产的等级为1的族产品；ConcreteFactory2生产的是等级为2的族产品。下面以上图为模型，写一个demo，测试抽象工厂模式。

抽象工厂：AbstractFactory接口

[html] view plain copy
  1. //抽象工厂，定义了生产族产品的方法；  
  2. public interface AbstractFactory {  
  3.     public ProductA factoryA();  
  4.     public ProductB factoryB();  
  5. }  


抽象产品：ProductA接口

[html] view plain copy
  1. //抽象产品A定义了产品的公共方法，产品A和B属于一个产品族  
  2. public interface ProductA {  
  3.     public void method1();  
  4.     public void method2();  
  5. }  


抽象产品：ProductB接口

[html] view plain copy
  1. //抽象产品B定义了产品的公共方法，产品A和B属于一个产品族  
  2. public interface ProductB {  
  3.     public void method1();  
  4.     public void method2();  
  5. }  


具体工厂（生产等级为2的族产品）：ConcreteFactory1类

[html] view plain copy
  1. //ConcreateFactory1是用来生产等级为1的产品A，B的具体工厂；  
  2. public class ConcreateFactory1 implements AbstractFactory {  
  3.   
  4.     //生产等级为1的产品A  
  5.     @Override  
  6.     public ProductA factoryA() {  
  7.         // TODO Auto-generated method stub  
  8.         return new ConcreateProductA1();  
  9.     }  
  10.   
  11.       
  12.     //生产等级为1的产品B  
  13.     @Override  
  14.     public ProductB factoryB() {  
  15.         // TODO Auto-generated method stub  
  16.         return new ConcreateProductB1();  
  17.     }  
  18.   
  19. }  


具体工厂（生产等级为1的族产品）：ConcreteFactory2类
[html] view plain copy
  1. public class ConcreateFactory2 implements AbstractFactory {  
  2.   
  3.     //生产等级为2的产品A  
  4.     @Override  
  5.     public ProductA factoryA() {  
  6.         // TODO Auto-generated method stub  
  7.         return new ConcreateProductA2();  
  8.     }  
  9.   
  10.     //生产等级为2的产品B  
  11.     @Override  
  12.     public ProductB factoryB() {  
  13.         // TODO Auto-generated method stub  
  14.         return new ConcreateProductB2();  
  15.     }  
  16. }  


具体产品（等级为1的A产品）：ConcreteProductA1类

[html] view plain copy
  1. //等级为1的具体产品A  
  2. public class ConcreateProductA1 implements ProductA {  
  3.   
  4.     @Override  
  5.     public void method1() {  
  6.         // TODO Auto-generated method stub  
  7.         System.out.println("等级为1的产品A的method1()");  
  8.     }  
  9.   
  10.     @Override  
  11.     public void method2() {  
  12.         // TODO Auto-generated method stub  
  13.         System.out.println("等级为1的产品A的method2()");  
  14.     }  
  15. }  


具体产品（等级为2的A产品）：ConcreteProductA2类

[html] view plain copy
  1. //等级为2的具体产品A  
  2. public class ConcreateProductA2 implements ProductA {  
  3.   
  4.     @Override  
  5.     public void method1() {  
  6.         // TODO Auto-generated method stub  
  7.         System.out.println("等级为2的产品A的method1()");  
  8.     }  
  9.   
  10.     @Override  
  11.     public void method2() {  
  12.         // TODO Auto-generated method stub  
  13.         System.out.println("等级为2的产品A的method2()");  
  14.     }  
  15. }  


具体产品（等级为1的B产品）：ConcreteProductB1类

[html] view plain copy
  1. //等级为1的产品B  
  2. public class ConcreateProductB1 implements ProductB{  
  3.   
  4.     @Override  
  5.     public void method1() {  
  6.         // TODO Auto-generated method stub  
  7.         System.out.println("等级为1的产品B的method1()");  
  8.     }  
  9.   
  10.     @Override  
  11.     public void method2() {  
  12.         // TODO Auto-generated method stub  
  13.         System.out.println("等级为1的产品B的method2()");  
  14.     }  
  15. }  


具体产品（等级为2的B产品）：ConcreteProductB2类

[html] view plain copy
  1. //等级为2的产品B  
  2. public class ConcreateProductB2 implements ProductB {  
  3.   
  4.     @Override  
  5.     public void method1() {  
  6.         // TODO Auto-generated method stub  
  7.         System.out.println("等级为2的产品B的method1()");  
  8.     }  
  9.   
  10.     @Override  
  11.     public void method2() {  
  12.         // TODO Auto-generated method stub  
  13.         System.out.println("等级为2的产品B的method2()");  
  14.     }  
  15. }  


使用场景：

  • JDK中体现：
    （1）Java.sql包
    （2）UIManager（swing外观）
类图：
设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较


===================================

简单工厂模式

简单工厂模式不是23种里的一种，简而言之，就是有一个专门生产某个产品的类。
比如下图中的鼠标工厂，专业生产鼠标，给参数0，生产戴尔鼠标，给参数1，生产惠普鼠标。

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

工厂模式

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。
戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。
生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。
后续直接调用鼠标工厂.生产鼠标()即可

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

抽象工厂模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。
也就是PC厂商是个父类，有生产鼠标，生产键盘两个接口。
戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。
创建工厂时，由戴尔工厂创建。
后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

在抽象工厂模式中，假设我们需要增加一个工厂

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承PC厂商。
之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类。
即可。

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较

在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。
之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。
以上。

设计模式——抽象工厂模式及在jdk中的应用+几种工厂模式的比较




相关推荐