Delphi 设计模式：《HeadFirst设计模式》Delphi代码---工厂模式之抽象工厂[转]


 1
 2 {《HeadFirst设计模式》工厂模式之抽象工厂 }
 3 { 抽象工厂的产品                       }
 4 { 编译工具：Delphi7.0                  }
 5 { E-Mail ：[email protected]          }
 6
 7unit uPizzaIngredient;
 8
 9interface
10
11type
12  TDough = class(TObject)
13  end;
14
15  TThinCrustDough = class(TDough)
16  end;
17
18  TThickCrustDough = class(TDough)
19  end;
20
21  ////////////////////////////////
22
23  TSauce = class(TObject)
24  end;
25
26  TMarinaraSauce = class(TSauce)
27  end;
28
29  TPlumTomatoSauce = class(TSauce)
30  end;
31
32  ////////////////////////////////
33
34  TCheese = class(TObject)
35  end;
36
37  TReggianoCheese = class(TCheese)
38  end;
39
40  TMozzarellaCheese = class(TCheese)
41  end;
42
43  //////////////////////////////////
44
45  TPepperoni = class(TObject)
46  end;
47
48  TSlicedPepperoni = class(TPepperoni)
49  end;
50
51  ////////////////////////////////////
52  
53  TClams = class(TObject)
54  end;
55
56  TFreshClams = class(TClams)
57  end;
58
59  TFrozenClams = class(TClams)
60  end;
61
62implementation
63
64end.


 1
 2 {《HeadFirst设计模式》工厂模式之抽象工厂 }
 3 { 抽象工厂                            }
 4 { 编译工具：Delphi7.0                 }
 5 { E-Mail ：[email protected]         }
 6
 7unit uPizzaIngredientFactory;
 8
 9interface
10
11uses
12  uPizzaIngredient;
13
14type
15  TPizzaIngredientFactory = class(TObject)
16  public
17    function CreateDough: TDough; virtual; abstract;
18    function CreateSauce: TSauce; virtual; abstract;
19    function CreateCheese: TCheese; virtual; abstract;
20    function CreatePepperoni: TPepperoni; virtual; abstract;
21    function CreateClams: TClams; virtual; abstract;
22  end;
23
24  TNYPizzaIngredientFactory = class(TPizzaIngredientFactory)
25  public
26    function CreateDough: TDough; override;
27    function CreateSauce: TSauce; override;
28    function CreateCheese: TCheese; override;
29    function CreatePepperoni: TPepperoni; override;
30    function CreateClams: TClams; override;
31  end;
32
33  TChicagoPizzaIngredientFactory = class(TPizzaIngredientFactory)
34  public
35    function CreateDough: TDough; override;
36    function CreateSauce: TSauce; override;
37    function CreateCheese: TCheese; override;
38    function CreatePepperoni: TPepperoni; override;
39    function CreateClams: TClams; override;
40  end;
41
42implementation
43
44{ TNYPizzaIngredientFactory }
45
46function TNYPizzaIngredientFactory.CreateCheese: TCheese;
47begin
48  Result := TReggianoCheese.Create;
49end;
50
51function TNYPizzaIngredientFactory.CreateClams: TClams;
52begin
53  Result := TFreshClams.Create;
54end;
55
56function TNYPizzaIngredientFactory.CreateDough: TDough;
57begin
58  Result := TThinCrustDough.Create;
59end;
60
61function TNYPizzaIngredientFactory.CreatePepperoni: TPepperoni;
62begin
63  Result := TSlicedPepperoni.Create;
64end;
65
66function TNYPizzaIngredientFactory.CreateSauce: TSauce;
67begin
68  Result := TMarinaraSauce.Create;
69end;
70
71{ TChicagoPizzaIngredientFactory }
72
73function TChicagoPizzaIngredientFactory.CreateCheese: TCheese;
74begin
75  Result := TMozzarellaCheese.Create;
76end;
77
78function TChicagoPizzaIngredientFactory.CreateClams: TClams;
79begin
80  Result := TFrozenClams.Create;
81end;
82
83function TChicagoPizzaIngredientFactory.CreateDough: TDough;
84begin
85  Result := TThickCrustDough.Create;
86end;
87
88function TChicagoPizzaIngredientFactory.CreatePepperoni: TPepperoni;
89begin
90  Result := TSlicedPepperoni.Create;
91end;
92
93function TChicagoPizzaIngredientFactory.CreateSauce: TSauce;
94begin
95  Result := TPlumTomatoSauce.Create;
96end;
97
98end.


  1
  2 {《HeadFirst设计模式》工厂模式之抽象工厂 }
  3 { 抽象工厂的用户                       }
  4 { 编译工具：Delphi7.0                  }
  5 { E-Mail ：[email protected]          }
  6
  7unit uPizza;
  8
  9interface
 10
 11uses
 12  uPizzaIngredient, uPizzaIngredientFactory;
 13
 14type
 15  TPizza = class(TObject)
 16  private
 17    procedure SetName(const Value: string);
 18  protected
 19    FName: string;
 20    FDough: TDough;
 21    FSauce: TSauce;
 22    FCheese: TCheese;
 23    FPepperoni: TPepperoni;
 24    FClams: TClams;
 25    FIngredientFactory: TPizzaIngredientFactory;
 26  public
 27    constructor Create(aIngredientFactory: TPizzaIngredientFactory);
 28    procedure Prepare; virtual; abstract;
 29    procedure Bake;
 30    procedure Cut;
 31    procedure Box;
 32    property Name: string read FName write SetName;
 33  end;
 34
 35  TCheesePizza = class(TPizza)
 36  public
 37    destructor Destroy; override;
 38    procedure Prepare; override;
 39  end;
 40
 41  TClamsPizza = class(TPizza)
 42  public
 43    destructor Destroy; override;
 44    procedure Prepare; override;
 45  end;
 46  
 47implementation
 48
 49{ TPizza }
 50
 51procedure TPizza.Bake;
 52begin
 53  Writeln(‘Bake for 25 minutes at 350‘);
 54end;
 55
 56procedure TPizza.Box;
 57begin
 58  Writeln(‘Place pizza in official PizzaStore box‘);
 59end;
 60
 61constructor TPizza.Create(aIngredientFactory: TPizzaIngredientFactory);
 62begin
 63  Self.FIngredientFactory := aIngredientFactory;
 64end;
 65
 66procedure TPizza.Cut;
 67begin
 68  Writeln(‘Cutting the pizza into diagonal slices‘);
 69end;
 70
 71procedure TPizza.SetName(const Value: string);
 72begin
 73  FName := Value;
 74end;
 75
 76{ TCheesePizza }
 77
 78destructor TCheesePizza.Destroy;
 79begin
 80  FDough.Free;
 81  FSauce.Free;
 82  FCheese.Free;
 83  inherited;
 84end;
 85
 86procedure TCheesePizza.Prepare;
 87begin
 88  Writeln(‘Preparing ‘ + Name);
 89  FDough  := FIngredientFactory.CreateDough;
 90  FSauce  := FIngredientFactory.CreateSauce;
 91  FCheese := FIngredientFactory.CreateCheese;
 92end;
 93
 94{ TClamsPizza }
 95
 96destructor TClamsPizza.Destroy;
 97begin
 98  FDough.Free;
 99  FSauce.Free;
100  FCheese.Free;
101  FClams.Free;
102  inherited;
103end;
104
105procedure TClamsPizza.Prepare;
106begin
107  Writeln(‘Preparing ‘ + Name);
108  FDough  := FIngredientFactory.CreateDough;
109  FSauce  := FIngredientFactory.CreateSauce;
110  FCheese := FIngredientFactory.CreateCheese;
111  FClams  := FIngredientFactory.CreateClams;
112end;
113
114end.


 1
 2 {《HeadFirst设计模式》工厂模式之抽象工厂 }
 3 { Pizza的用户                         }
 4 { 编译工具：Delphi7.0                 }
 5 { E-Mail ：[email protected]         }
 6
 7unit uPizzaStore;
 8
 9interface
10
11uses
12  uPizza, uPizzaIngredientFactory;
13
14type
15  TPizzaStore = class(TObject)
16  protected
17    FPizza: TPizza;
18    FIngredientFactory: TPizzaIngredientFactory;
19  public
20    destructor Destroy; override;
21    function OrderPizza(Category: Integer): TPizza;
22    function CreatePizza(Style: Integer): TPizza; virtual; abstract;
23  end;
24
25  TNYPizzaStore = class(TPizzaStore)
26  public
27    function CreatePizza(Style: Integer): TPizza; override;
28  end;
29
30  TChicagoPizzaStore = class(TPizzaStore)
31  public
32    function CreatePizza(Style: Integer): TPizza; override;
33  end;
34
35implementation
36
37{ TPizzaStore }
38
39destructor TPizzaStore.Destroy;
40begin
41  FPizza.Free;
42  FIngredientFactory.Free;
43  inherited;
44end;
45
46function TPizzaStore.OrderPizza(Category: Integer): TPizza;
47begin
48  FPizza := CreatePizza(Category);
49  FPizza.Prepare;
50  FPizza.Bake;
51  FPizza.Cut;
52  FPizza.Box;
53
54  Result := FPizza;
55end;
56
57{ TNYPizzaStore }
58
59function TNYPizzaStore.CreatePizza(Style: Integer): TPizza;
60begin
61  FIngredientFactory := TNYPizzaIngredientFactory.Create;
62  FPizza := nil;
63  case Style of
64    0: begin
65         FPizza := TCheesePizza.Create(FIngredientFactory);
66         FPizza.Name := ‘New York Style Cheese Pizza‘;
67       end;
68    1: begin
69         FPizza := TClamsPizza.Create(FIngredientFactory);
70         FPizza.Name := ‘New York Style Clams Pizza‘;
71       end;
72    //2: 其它风味的 New York Pizza
73    //
74  end;
75  Result := FPizza;
76end;
77
78{ TChicagoPizzaStore }
79
80function TChicagoPizzaStore.CreatePizza(Style: Integer): TPizza;
81begin
82  FIngredientFactory := TChicagoPizzaIngredientFactory.Create;
83  case Style of
84    0: begin
85         Result := TCheesePizza.Create(FIngredientFactory);
86         Result.Name := ‘Chicago Style Cheese Pizza‘;
87       end;
88    1: begin
89         Result := TClamsPizza.Create(FIngredientFactory);
90         Result.Name := ‘Chicago Style Clams Pizza‘;
91       end;
92    //2: 其它风味的 Chicago Pizza
93    //
94  else
95    Result := nil;
96  end;
97end;
98
99end.


 1
 2 {《HeadFirst设计模式》工厂模式之抽象工厂 }
 3 { 客户端                              }
 4 { 编译工具：Delphi7.0                 }
 5 { E-Mail ：[email protected]          }
 6
 7program pPizzaStore;
 8
 9{$APPTYPE CONSOLE}
10
11uses
12  uPizzaIngredient in ‘uPizzaIngredient.pas‘,
13  uPizzaIngredientFactory in ‘uPizzaIngredientFactory.pas‘,
14  uPizza in ‘uPizza.pas‘,
15  uPizzaStore in ‘uPizzaStore.pas‘;
16
17var
18  PizzaStore: TPizzaStore;
19  Pizza: TPizza;
20  
21begin
22  PizzaStore := TNYPizzaStore.Create;
23  Pizza := PizzaStore.OrderPizza(0);
24  Writeln(‘Ethan ordered a ‘ + Pizza.Name);
25  Writeln;
26  Pizza := PizzaStore.OrderPizza(1);
27  Writeln(‘Ethan ordered a ‘ + Pizza.Name);
28  PizzaStore.Free;
29  
30  Writeln;
31  Writeln(‘  **********************************  ‘);
32  Writeln;
33
34  PizzaStore := TChicagoPizzaStore.Create;
35  Pizza := PizzaStore.OrderPizza(0);
36  Writeln(‘Joel ordered a ‘ + Pizza.Name);
37  Writeln;
38  Pizza := PizzaStore.OrderPizza(1);
39  Writeln(‘Joel ordered a ‘ + Pizza.Name);
40  PizzaStore.Free;
41
42  Readln;
43end.

运行结果：

时间： 2024-10-12 08:03:50

Delphi 设计模式：《HeadFirst设计模式》Delphi代码---工厂模式之抽象工厂[转]的相关文章

工厂模式和抽象工厂模式

工厂模式: 定义一个用于创建对象的接口,让他的子类决定实例化哪个类.使类的实例化延迟到子类. 1.普通的工厂模式: public class GoodProduct implements Product { private String prodInfo = "Iam the good prod"; public String getProductInfo() { // TODO Auto-generated method stub return this.prodInfo; } pu

[设计模式篇]工厂模式和抽象工厂模式

最近在看Head First的Design Pattern,想想去年候捷来学校给我们讲Design Pattern,但当时水平太弱根本听不懂,今年想趁机再好好学一波,候捷反而不来了,哎,人生就是这样,有些机会真的搞不好只有一次了,所以还是要多多珍惜,不然... ... (再水下去估计没人看了,废话少说,这篇就当一个开篇之作吧,虽然已经看了不少了.) Head First这本书用了一个披萨店的例子,从简单工厂(严格来说这不算一种Gof的设计模式,更像是一种编程习惯),到介绍工厂模式,再介绍到抽象工

设计模式学习（二）——简单工厂模式、工厂模式、抽象工厂模式

最近抽时间将之前看过的"程序人生"公众号推送的一篇工厂模式的介绍进行了实践,为了加深自己理解,特将自己的学习理解记录于此.初识设计模式,就被设计模式的精妙深深吸引,感觉脱离设计模式的代码就失去了美丽.作为一个测试,平日写代码的机会肯定不如开发多,但是希望自己能通过努力逐步提升代码水平,有一天也能写出优美的代码.如果有对于工厂模式或其他设计模式感兴趣的朋友欢迎一起探讨. 一.简单工厂模式 定义:专门定义一个类用来创建其他类的实例,被创建的实例通常具有共同的父类. 场景一:恰巧今天,老大兴

设计模式--工厂模式和抽象工厂模式

工厂模式的英文原文是:Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory method lets a class defer instantiation to subclass. 意思是定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到子类. 工厂模式主要是为创建对象提供了接口,工厂模式可分为三类: 简单

【设计模式】重新理解简单工厂模式、工厂模式、抽象工厂模式

最近后台工作部分还算顺利,数据库Dao层使用简单工厂模式,一开始自己还是觉得是工厂模式,因为我没有深入了解过简单工厂模式与工厂模式的区别,后来通过复习工厂模式的时候才发现自己的理解是错误的. 在后台数据库层开发部分,自己定义了Dao接口用于表示对数据库操作的动作.对应每个Dao都有一个实现类对应,然后通过定义一个Factory类通过静态方法获取Dao接口的实例. 其实这种方式是属于简单工厂模式,而不是工厂模式,因为工厂模式中工厂类也是一个接口,产品接口通过工厂类的实例构建出来,看看下面的描述:

简单工厂方法，工厂模式，抽象工厂模式

简要对比 简单工厂方法是一种编程习惯,不是设计模式:一个电脑工厂,负责生产不同的电脑. 工厂模式:联想工厂负责生产联想电脑,戴尔工厂负责生产戴尔电脑(实际的工厂类),它们都有生产电脑的方法(实现公共接口). 抽象工厂:联想工厂既要生产电脑,又要生产鼠标:戴尔工厂既要生产电脑,又要生产鼠标(实际的工厂类).他们都有生产电脑和鼠标的方法(实现公共接口).其中生产鼠标和电脑都是用工厂模式实现(包含多个工厂模式). 抽象工厂模式的优点是可以保证同一个工厂返回的同一个产品族,比如使用罗技的工厂就只会生产罗

工厂模式[3] 抽象工厂 Abstract Factory

简介 1.简单工厂,或静态工厂,产品接口 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类或实现同一接口 优点:客户端可以直接消费产品,而不必关心具体产品的实现(不关心对象的构造方法是怎么new的),消除了客户端直接创建产品对象的责任,实现了对责任的分割. 缺点:工厂类记录了所有产品的创建逻辑,一旦不能正常工作,整个系统都会受到影响:而且当产品种类多.结构复杂的时候,把所有创建工作放进一个工厂中来,会使后期程序的扩展较为困难. 2.工厂方法,工厂接口+产品接口 定义:在

工厂模式之抽象工厂模式

图显示有问题.可直接看: 点击打开链接 场景问题 举个生活中常见的样例--组装电脑,我们在组装电脑的时候.通常须要选择一系列的配件,比方CPU.硬盘.内存.主板.电源.机箱等. 为讨论使用简单点,仅仅考虑选择CPU和主板的问题. 其实.在选择CPU的时候.面临一系列的问题,比方品牌.型号.针脚数目.主频等问题.仅仅有把这些问题都确定下来,才干确定详细的CPU. 相同,在选择主板的时候.也有一系列问题.比方品牌.芯片组.集成芯片.总线频率等问题,也仅仅有这些都确定了,才干确定详细的主板. 选择不同

Objective-C 工厂模式(下) -- 抽象工厂模式

相比简单工厂模式, 只有一个工厂 能生产的手机也是固定的 抽象工厂模式类似于有很多家工厂, 当用户要买什么手机就创建对应的工厂去生产 比如用户要买iPhone就创建一个Apple工厂来生产手机, 要买Android手机就创建一个Goolge工厂 这样创建工厂, 工厂, 用户这样就是我们要考虑的因素 (其实还有手机, 这里就跳过不讲了跟简单工厂模式里面一样) 创建工厂要有一个管理对象, 来根据客户的需求自动创建相应的工厂 工厂只要负责生产手机就好了 现在来构建代码 先写一个基本工厂模型 BaseF