设计模式(3)-对象创建型模式-Abstract Factory模式
1.对象创建型模式
1.3 Abstract Factory模式
1.3.1 需求
在下面情况能够使用Abstract Factory模式:
• 一个系统要独立于它的产品的创建、组合和表示时(这个需求和FactoryMethod类似)。
• 一个系统要由多个产品系列中的一个来配置时(这个需求也和Factory Method类似)。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时(这个需求表明一个工厂要创建多个相关的产品对象，是比FactoryMethod多的需求)。
• 当你提供一个产品类库，而仅仅想显示它们的接口而不是实现时(这个也与FactoryMethod类似)。
依据这个适应场景能够看出，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory Method模式(常常直接成为工厂模式)是为一类对象提供创建接口或延迟对象的创建到子类中实现。
1.3.2功能
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们详细的类。
1.3.3 结构
•A b s t r a c t F a c t o r y ( Wi d g e t F a c t o r y )
— 声明一个创建抽象产品对象的操作接口。
•C o n c r e t e F a c t o r y ( M o t i f Wi d g e t F a c t o r y ，P M Wid g e t F a c t o r y )
— 实现创建详细产品对象的操作。
•A b s t r a c t P r o d u c t ( Wi n d o w s，S c r o l l B a r )
— 为一类产品对象声明一个接口。
•C o n c r e t e P r o d u c t ( M o t i f Wi n d o w，M o t i f S c r o l l B a r )
— 定义一个将被对应的详细工厂创建的产品对象。
— 实现Ab s t r a c t P r o d u c t接口。
•C l i e n t
— 仅使用由Ab s t r a c t F a c t o r y和Ab s t r a c t P r o d u c t类声明的接口。
1.3.4 优缺点
长处：
1. 分类了详细的类：由于一个工厂封装创建产品对象的责任和过程，客户假设使用这样的模式开发一个库，使用这个库的程序就叫做客户）将仅仅须要通过抽象接口来操作实例。这意味着客户与产品类的实现分离，并且客户不须要知道产品类的详细名称,仅仅须要知道要生成这个系列产品的工厂的名称。
2. 易于交换产品系列：在改动代码时，客户程序中仅仅须要改动要生成产品的工厂，不须要改动其它不论什么代码。
3. 有利于产品的一致性：它保证了产品簇的相关性，当一个产品族中的多个对象被设计成一起工作时，它可以保证client始终仅仅使用同一个产品族中的对象。
缺点：
难以支持新种类的产品. 这是由于A b s t r a c t F a c t or y接口确定了能够被创建的产品集合。 支持新种类的产品就须要扩展该工厂接口，这将涉及A b s t r a c t F a c t o r y类及其全部子类的改变。正所谓鱼与熊掌，不可兼得啊，你打包组合在一起，自然要承担这个缺点。
1.35 样例-C++
//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_
class AbstractProductA
{
public:
virtual ~AbstractProductA();
protected:
AbstractProductA();
private:
};
class AbstractProductB
{
public:
virtual ~AbstractProductB();
protected:
AbstractProductB();
private:
};
class ProductA1 :publicAbstractProductA
{
public:
ProductA1();
~ProductA1();
protected:
private:
};
class ProductA2 :publicAbstractProductA
{
public:
ProductA2();
~ProductA2();
protected:
private:
};
class ProductB1 :publicAbstractProductB
{
public:
ProductB1();
~ProductB1();
protected:
private:
};
class ProductB2 :publicAbstractProductB
{
public:
ProductB2();
~ProductB2();
protected:
private:
};
#endif //~_PRODUCT_H_ECT_H_
//Product.cpp
#include"Product.h"
#include<iostream>
using namespace std;
AbstractProductA::AbstractProductA()
{}
AbstractProductA::~AbstractProductA()
{}
AbstractProductB::AbstractProductB()
{
}
AbstractProductB::~AbstractProductB()
{
}
ProductA1::ProductA1()
{
cout << "ProductA1..."<< endl;
}
ProductA1::~ProductA1()
{
}
ProductA2::ProductA2()
{
cout << "ProductA2..."<< endl;
}
ProductA2::~ProductA2()
{
}
ProductB1::ProductB1()
{
cout << "ProductB1..."<< endl;
}
ProductB1::~ProductB1()
{
}
ProductB2::ProductB2()
{
cout << "ProductB2..."<< endl;
}
ProductB2::~ProductB2()
{
}
//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
virtual ~AbstractFactory();
virtual
AbstractProductA*
CreateProductA() = 0;
virtual
AbstractProductB*
CreateProductB() = 0;
protected:
AbstractFactory();
private:
};
class ConcreteFactory1 :publicAbstractFactory
{
public:
ConcreteFactory1();
~ConcreteFactory1();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:
private:
};
class ConcreteFactory2 :publicAbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:
private:
};
#endif //~_ABSTRACTFACTORY_H_
//AbstractFactory.cpp
#include"AbstractFactory.h"
#include"Product.h"
#include<iostream>
using namespace std;
AbstractFactory::AbstractFactory()
{
}
AbstractFactory::~AbstractFactory()
{
}
ConcreteFactory1::ConcreteFactory1()
{
}
ConcreteFactory1::~ConcreteFactory1()
{
}
AbstractProductA*
ConcreteFactory1::CreateProductA()
{
return newProductA1();
}
AbstractProductB*
ConcreteFactory1::CreateProductB()
{
return newProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{
}
ConcreteFactory2::~ConcreteFactory2()
{
}
AbstractProductA*
ConcreteFactory2::CreateProductA()
{
return newProductA2();
}
AbstractProductB*
ConcreteFactory2::CreateProductB()
{
return newProductB2();
}
//main.cpp
#include"AbstractFactory.h"
#include<iostream>
using namespace std;
int main(int
argc, char*argv[])
{
AbstractFactory* cf1 =
new
ConcreteFactory1();
cf1->CreateProductA();
cf1->CreateProductB();
AbstractFactory* cf2 =
new
ConcreteFactory2();
cf2->CreateProductA();
cf2->CreateProductB();
return 0;
}
1.3.5 样例-JAVA
1. //抽象产品
2. UpperClothes.java
3. public abstract class UpperClothes {
4. public abstract int getChestSize();
5. public abstract int getHeight();
6. public abstract String getName();
7. }
8. Trousers.java
9. public abstract class Trousers {
10. public abstract int getWaistSize();
11. public abstract int getHeight();
12. public abstract String getName();
13.}
14.//详细产品
15.WesternUpperClothes.java
16.public class WesternUpperClothes extends UpperClothes {
17. private int chestSize;
18. private int height;
19. private String name;
20. WesternUpperClothes(String name,int chestSize,int height){
21. this.name=name;
22. this.chestSize=chestSize;
23. this.height=height;
24. }
25. public int getChestSize() {
26. return chestSize;
27. }
28. public int getHeight() {
29. return height;
30. }
31. public String getName() {
32. return name;
33. }
34.}
35.CowboyUpperClothes.java
36.public class CowboyUpperClothes extends UpperClothes {
37. private int chestSize;
38. private int height;
39. private String name;
40. CowboyUpperClothes(String name,int chestSize,int height){
41. this.name=name;
42. this.chestSize=chestSize;
43. this.height=height;
44. }
45. public int getChestSize() {
46. return chestSize;
47. }
48. public int getHeight() {
49. return height;
50. }
51. public String getName () {
52. return name;
53. }
54.}
55.WesternTrousers.java
56.public class WesternTrousers extends Trousers {
57. private int waistSize;
58. private int height;
59. private String name;
60. WesternTrousers(String name,int waistSize,int height){
61. this.name=name;
62. this.waistSize=waistSize;
63. this.height=height;
64. }
65. public int getHeight() {
66. return height;
67. }
68. public String getName() {
69. return name;
70. }
71. public int getWaistSize() {
72. return waistSize;
73. }
74.}
75.CowboyTrousers.java
76.public class CowboyTrousers extends Trousers {
77. private int waistSize;
78. private int height;
79. private String name;
80. CowboyTrousers(String name,int waistSize,int height){
81. this.name=name;
82. this.waistSize=waistSize;
83. this.height=height;
84. }
85. public int getHeight() {
86. return height;
87. }
88. public String getName() {
89. return name;
90. }
91. public int getWaistSize() {
92. return waistSize;
93. }
94.}
95.//抽象工厂
96.ClothesFactory.java
97.public abstract class ClothesFactory {
98. public abstract UpperClothes createUpperClothes(int chestSize,int height);
99. public abstract Trousers createTrousers(int waistSize,int height);
100. }
101. //详细工厂
102. BeijingClothesFactory.java
103. public class BeijingClothesFactory extends ClothesFactory {
104. public Trousers createTrousers(int waistSize, int height) {
105. return new WesternTrousers("北京牌裤子",waistSize,height);
106. }
107. public UpperClothes createUpperClothes(int chestSize, int height) {
108. return new WesternUpperClothes("北京牌上衣",chestSize,height);
109. }
110. }
111. ShanghaiClothesFactory.java
112. public class ShanghaiClothesFactory extends ClothesFactory {
113. public Trousers createTrousers(int waistSize, int height) {
114. return new WesternTrousers("上海牌裤子",waistSize,height);
115. }
116. public UpperClothes createUpperClothes(int chestSize, int height) {
117. return new WesternUpperClothes("上海牌上衣",chestSize,height);
118. }
119. }
package DesignPattern;
public
class TestMain {
/**
* @param args
*/
public
static void main(String[] args){
ClothesFactoryf=newShanghaiClothesFactory();
//ClothesFactoryf=new BeijingClothesFactory();
Trouserst = f.createTrousers(13, 14);
System.out.println(t.getName());
UpperClothesuc=f.createUpperClothes(13,14);
System.out.println(uc.getName());
}
}
设计模式(3)-对象创建型模式-Abstract Factory模式的更多相关文章
- 【创建型】Abstract Factory模式 & Factory Method模式
本文主要介绍简单工厂模式与抽象工厂模式.以下如有叙述不当之处,欢迎批评指正,欢迎交流探讨. 一:简单工厂模式 在23种设计模式中,简单工厂模式其实是不在列的,但理解该模式对于抽象工厂模式的思想理解是有 ...
- 设计模式(4)-对象创建型模式-Prototype模式
1.对象创建型模式 1.4 Protoype模式 1.4.1需求 通过拷贝原形对象创建新的对象. 1.4.2结构 •P r o t o t y p e(Gr a p h i c) - ...
- JAVA设计模式 3【创建型】理解工厂模式与抽象工厂模式
上一节我们已经学习了原型模式,稍微复习一下:通过重写Object 类的clone() 方法实现浅克隆,浅克隆也要实现Cloneable 标记接口.而深克隆则是将对象通过序列化和反序列化 的方式进行创建 ...
- JAVA设计模式 4【创建型】理解建造者模式
Hello,又是拖了几天更,实在是忙的要死,有时候忙累了,真的就是倒头睡的那种,刚好今天闲下来了.今天来更新一篇建造者模式. 其实建造者模式,我们已经在上一节已经有了解过了.只不过是上一节没有提到这样 ...
- 设计模式可复用面向对象软件设计基础之对象创建型模式—ABSTRACT FACTORY（ 抽象工厂）
意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 适用性 在以下情况可以使用 Abstract Factory模式 • 一个系统要独立于它的产品的创建.组合和表示时. • 一 ...
- C++设计模式 之 “对象创建”模式：Factory Method、Abstract Factory、Prototype、Builder
part 0 “对象创建”模式 通过“对象创建” 模式绕开new,来避免对象创建(new)过程中所导致的紧耦合(依赖具体类),从而支持对象创建的稳定.它是接口抽象之后的第一步工作. 典型模式 Fact ...
- 对象创建型模式------Abstract Factory(抽象工厂）
1. 意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.2. 别名 Kit3. 动机 假设我们要开发一款游戏,当然为了吸引更多的人玩,游戏难度不能太大 ...
- 【设计模式】抽象工厂模式 Abstract Factory Pattern
简单工厂模式是一个工厂类根据工厂方法的参数创建不出不同的产品, 工厂方法模式是每一个产品都有一个一一对应的工厂负责创建该产品.那么今天要讲的抽象工厂模式是一个工厂能够产生关联的一系列产品.抽象工厂模式 ...
- 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)
原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factor ...
随机推荐
- wildfly部署solr.war
1.添加solr/home配置,有两种途径: 一个是修改solr.war包的web.xml,路径如下:solr-4.7.2.rar\WEB-INF\web.xml,添加如下内容:
- HTML中常用鼠标样式
语法:cursor : auto | all-scroll | col-resize| crosshair | default | hand | move | help | no-drop | not ...
- python中关于list列表的增删查改操作
python中list的操#python创建列表的时候,会以堆栈的形式存放数据,从右向左往堆栈中存放数据 movies=["The holy Grail","The li ...
- Activity的学习
安卓的四大组件分别是 Activity ,Service服务, BroadcastReceiver广播接收器,ContentProvide内容提供器 . Activity: Activity是应用程序 ...
- ORA-16018: cannot use LOG_ARCHIVE_DEST with LOG_ARCHIVE_DEST_n or DB_RECOVERY_FILE_DEST【error收集】
之前一直没有注意一个事情, 关于设置archive归档路径设置的问题. 设置数据库为归档模式的命令: 1.首先要切换到mount状态: 2.执行alter system archivelog; 3.查 ...
- 前端/html5效果收藏
H5应用 9款漂亮的H5效果 8款漂亮的H5效果 36漂亮的button效果 颜色RGB表 省市二级联动
- Secure CRT 如何连接虚拟机里面的CentOS系统——当主机使用无线网的时候 作者原创 欢迎转载
第一步:设置自己的无线网,并且分享给VM8这个虚拟网卡 第二步:查看VM8网卡的IP地址,如图是192.168.137.1 第三步:设置虚拟机的配置:选择VM8网卡并且是NAT的 第四步:设置虚拟机里 ...
- 基于jQuery编写的页面跳转简单的小插件
其实这个很简单,就是一个脚本函数和两个参数(url,jupetime), 开始实现步骤: 1.像页面引用一个jquery工具包 2.在javascript脚本编写自定义方法: 方法声明: $.exte ...
- 3.4 C与汇编程序的相互调用
为了提高代码执行效率,内核源代码中有些地方直接使用了汇编语言编制.这就会涉及在两种语言编制的程序之间相互调用的问题. 函数调用包括从一块代码到另一块代码之间的双向数据传递和执行控制转移.数据传递通过函 ...
- bat 小工具
@echo ************************************************************************:start@echo offset /p ...