第三天：代理模式工厂方法抽象工厂

代理模式:为其他对象提供一种代理以控制这个对象的访问.

1.远程代理- .net中的webservice 客户端引用webservice服务时,生成的webreference就是代理模式应用

2.虚拟代理- 浏览器加载页面中的图片资源时,通过代理获得图片基本大小信息.

3.保护代理- 操作系统对内核的权限保护

4.智能指针- 原始变量的引用计数

View Code

 1 class Subject
 2 {
 3 public:
 4     virtual void Request() = 0;    
 5 };
 6 
 7 class RealSubject : public Subject
 8 {
 9 public:
10     virtual void Request()
11     {
12         //do something
13     }
14 };
15 
16 class Proxy : public Subject
17 {
18 public:
19     virtual void Request()
20     {
21         realsubject_.Request();
22     }
23 
24 private:
25     RealSubject realsubject_;
26 };
27 
28 //client
29 int main()
30 {
31     Proxy xy;
32     xy.Request();
33 }

工厂方法:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法是一个类的实例化延迟到其子类.

工厂方法是为了解决简单工厂在增加同类新产品时违反ocp原则而构造的.

View Code

 1 class Product
 2 {
 3 
 4 };
 5 
 6 class ConcreteProduct : public Product
 7 {
 8 
 9 };
10 
11 class Factory
12 {
13 public:
14     virtual Product* Create() = 0;
15 };
16 
17 class ConcreteFactory : public Factory
18 {
19 public:
20     virtual Product* Create()
21     {
22         return new ConcreteProduct;
23     }
24 };
25 
26 //如果要增加新产品
27 class ProductB : public Product
28 {
29     
30 };
31 
32 class NewFactory : public Factory
33 {
34 public:
35     virtual Product* Create()
36     {
37         return new ProductB;
38     }
39 };
40 
41 //client
42 int main()
43 {
44     ConcreateFactory fy;
45     Product* pd = fy.Create();
46     delete pd;
47     
48     //增加了新产品, 只需要增加2个类,而不需要修改已有工厂和产品类
49     NewFacotry fn;
50     Product* pn = fn.Create();
51     delete pn;
52 }

抽象工厂:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.

抽象工厂是在工厂方法的基础上构造, 为了解决在系统中增加不同的产品系列(族).

View Code

 1 class Product{};
 2 class ProductA : public Product{};
 3 class ProductB : public Product{};
 4 
 5 class OtherProduct{};
 6 class OtherProductA : public OtherProduct{};
 7 class OtherProductB : public OtherProduct{};
 8 
 9 class AbstractFactory
10 {
11 public:
12     virtual Product* Create() = 0;
13     virtual OtherProduct* CreateOther() = 0;
14 };
15 
16 class ConcreteFactoryA : public AbstractFactory
17 {
18 public:
19     virtual Product* Create()
20     {
21         return new ProductA;
22     }
23     
24     virtual OtherProduct* CreateOther()
25     {
26         return new OhterProductA;
27     }
28 };
29 
30 class ConcreteFactoryB : public AbstractFactory
31 {
32 public:
33     virtual Product* Create()
34     {
35         return new ProductB;
36     }
37     
38     virtual OtherProduct* CreateOther()
39     {
40         return new OhterProductB;
41     }
42 };
43 
44 
45 //client
46 int main()
47 {
48     ConcreateFactoryA fac; 
49     //当要将产品族切换到OtherProduct时 只需要在客户端修改实例化抽象工厂的地方
50     //ConcreateFactoryB fac; 
51     
52     Product* pd = fac.Create();
53     delete pd;
54     
55     OtherProduct* pod = fac.CreateOther();
56     delete pod;
57 }

常用于多数据库多表的数据访问场景下. m种数据库对应m个继承抽象工厂类的子类, 数据库中由n个表组成,则此模式下就具有n个抽象产品类,抽象工厂基类具有n个创建产品的方法.