设计模式(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 ...
随机推荐
- JQuery图片轮换 nivoSlider图片轮换
效果图: 第一步:添加引用 <script src="jquery-ui-1.9.2.custom.min.js" type="text/javascript&qu ...
- asp.net中应用JQuery.pagination分页
JQuery.pagination这款分页控件非常好用,可实现无刷新分页,为了方便下次做项目便于拷贝,所以在此发布一下,具体的实现流程如下: 效果图: JQuery.pagination的各个参数的说 ...
- 基于脚本的动画的计时控制（“requestAnimationFrame”）(转）
requestAnimationFrame 方法的支持,该方法通过在系统准备好绘制动画帧时调用该帧,从而为创建动画网页提供了一种更平滑更高效的方法.在此 API 之前,使用 setTimeout 和 ...
- linux RedHat 5 更新vim.
概述: 想装 ctags,装不上.看到老外有篇日志,是在vi 7.2版本上运行.怕是vi版本的原因,于是想升级,网上升级的方法写得少,有的写的太无语了,只有他自己看得懂.这里,简单说下.搞半天了,终于 ...
- BIND9详解之日志篇
在默认情况下,BIND把日志消息写到/var/log/messages文件中,而这些日志消息是非常少的,主要就是启动,关闭的日志记录和一些严重错误的消息,所以要详细记录服务器的运行状况,需要自己配置服 ...
- windows下安装php笔记
为了更深入的理解下服务端的配置 ,上篇文章讲了如何在windows下安装apache , 接下来再研究下在windows下安装php并且结合apache运行php环境, 纯属学习用 ^^ ,如果嫌麻烦 ...
- django安装
见 http://jingyan.baidu.com/article/466506580e7d29f549e5f8b6.html 下载安装python下载解压django cmd进入django目录, ...
- 转自：http://blog.sina.com.cn/s/blog_86e874d30101e3d8.html（谢谢原文作者），Win7下安装CentOS 6.5双系统
经过一下午的折腾,终于在64位的Windows 7上面成功安装了CentOS 6.5(64bit)系统,中途因为硬盘分区的问题失败了一次.下面是安装过程: 在安装过程中借助了这篇文章的内容:http: ...
- 高级应用与部署 —— 主程序与web目录分离
在网站部署中,考虑网站的安全行问题,可以将您的网站主程序与web目录分离,使主程序在web目录之外,从而提高网站的安全性. 分离方法 1.将phpcms v9中程序主框架目录phpcms移动至web目 ...
- centos 下使用sublime
CentOS 之 Sublime text3 安装及配置(不支持中文输入) sublime text 的界面友好,自动补全功能也不错. (本来用vim+php_function.txt的形式进行补全的 ...