Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---策略模式之MiniDuckSimulator[转]


 1
 2{《HeadFirst设计模式》之策略模式 }
 3{ 本单元中的类为策略类           }
 4{ 编译工具: Delphi7.0           }
 5{ E-Mail : [email protected]   }
 6
 7unit uStrategy;
 8
 9interface
10
11type
12  {飞行接口,及其实现类 }
13
14  IFlyBehavior = Interface(IInterface)
15    procedure Fly;
16  end;
17
18  TFlyWithWings = class(TInterfacedObject, IFlyBehavior)
19  public
20    procedure Fly;
21  end;
22
23  TFlyNoWay = class(TInterfacedObject, IFlyBehavior)
24  public
25    procedure Fly;
26  end;
27
28  TFlyRocketPowered = class(TInterfacedObject, IFlyBehavior)
29  public
30    procedure Fly;
31  end;
32
33  {叫声接口,及其实现类}
34
35  IQuackBehavior = Interface(IInterface)
36    procedure Quack;
37  end;
38
39  TQuack = class(TInterfacedObject, IQuackBehavior)
40  public
41    procedure Quack;
42  end;
43
44  TMuteQuack = class(TInterfacedObject, IQuackBehavior)
45  public
46    procedure Quack;
47  end;
48
49  TSqueak = class(TInterfacedObject, IQuackBehavior)
50  public
51    procedure Quack;
52  end;
53
54implementation
55
56{ TFlyWithWings }
57
58procedure TFlyWithWings.Fly;
59begin
60  Writeln(‘I am flying!‘);
61end;
62
63{ TFlyNoWay }
64
65procedure TFlyNoWay.Fly;
66begin
67  Writeln(‘I can not fly!‘);
68end;
69
70{ TFlyRocketPowered }
71
72procedure TFlyRocketPowered.Fly;
73begin
74  Writeln(‘I am flying with a rocket!‘);
75end;
76
77{ TQuack }
78
79procedure TQuack.Quack;
80begin
81  Writeln(‘Quack‘);
82end;
83
84{ TMuteQuack }
85
86procedure TMuteQuack.Quack;
87begin
88  Writeln(‘<Silence>‘);
89end;
90
91{ TSqueak }
92
93procedure TSqueak.Quack;
94begin
95  Writeln(‘Squeak‘);
96end;
97
98end.


  1
  2{《HeadFirst设计模式》之策略模式           }
  3{ 本单元中的类为策略的用户,                }
  4{ 一般策略模式中的上下文接口已包含在用户类中。}
  5{ 编译工具: Delphi7.0                     }
  6{ E-Mail : [email protected]             }
  7
  8unit uDuck;
  9
 10interface
 11
 12uses
 13  uStrategy;
 14
 15type
 16  { 鸭子抽象类 }
 17
 18  TDuck = class(TObject)
 19  protected
 20    FFlyBehavior  : IFlyBehavior;
 21    FQuackBehavior: IQuackBehavior;
 22  public
 23    procedure Display; virtual; abstract;
 24    procedure PerformFly;
 25    procedure PerformQuack;
 26    procedure Swim;
 27    procedure SetFlyBehavior(FlyBehavior: IFlyBehavior);
 28    procedure SetQuackBehavior(QuackBehavior: IQuackBehavior);
 29  end;
 30
 31  { 绿头鸭具体类 }
 32
 33  TMallardDuck = class(TDuck)
 34  public
 35    constructor Create;
 36    destructor Destroy; override;
 37    procedure Display; override;
 38  end;
 39
 40  { 模型鸭具体类 }
 41  
 42  TModelDuck = class(TDuck)
 43  public
 44    constructor Create;
 45    destructor Destroy; override;
 46    procedure Display; override;
 47  end;
 48
 49implementation
 50
 51{ TDuck }
 52
 53procedure TDuck.PerformFly;
 54begin
 55  FFlyBehavior.Fly;
 56end;
 57
 58procedure TDuck.PerformQuack;
 59begin
 60  FQuackBehavior.Quack;
 61end;
 62
 63procedure TDuck.SetFlyBehavior(FlyBehavior: IFlyBehavior);
 64begin
 65  FFlyBehavior := FlyBehavior;
 66end;
 67
 68procedure TDuck.SetQuackBehavior(QuackBehavior: IQuackBehavior);
 69begin
 70  FQuackBehavior := QuackBehavior;
 71end;
 72
 73procedure TDuck.Swim;
 74begin
 75  Writeln(‘All ducks float, even decoys!‘);
 76end;
 77
 78{ TMallardDuck }
 79
 80constructor TMallardDuck.Create;
 81begin
 82  FQuackBehavior := TQuack.Create;
 83  FFlyBehavior   := TFlyWithWings.Create;
 84end;
 85
 86destructor TMallardDuck.Destroy;
 87begin
 88  FQuackBehavior := nil;
 89  FFlyBehavior   := nil;
 90  inherited;
 91end;
 92
 93procedure TMallardDuck.Display;
 94begin
 95  Writeln(‘I am a real mallard duck‘);
 96end;
 97
 98{ TModelDuck }
 99
100constructor TModelDuck.Create;
101begin
102  FFlyBehavior   := TFlyNoWay.Create;
103  FQuackBehavior := TQuack.Create;
104end;
105
106destructor TModelDuck.Destroy;
107begin
108  FQuackBehavior := nil;
109  FFlyBehavior   := nil;
110  inherited;
111end;
112
113procedure TModelDuck.Display;
114begin
115  Writeln(‘I am a model duck‘);
116end;
117
118end.
119


 1
 2{《HeadFirst设计模式》之策略模式 }
 3{ 客户端                       }
 4{ 编译工具: Delphi7.0          }
 5{ E-Mail : [email protected]  }
 6
 7program pMiniDuckSimulator;
 8
 9{$APPTYPE CONSOLE}
10
11uses
12  SysUtils,
13  uDuck in ‘uDuck.pas‘,
14  uStrategy in ‘uStrategy.pas‘;
15
16var
17  Mallard: TDuck;
18  Model  : TDuck;
19  FlyRocketPowered: IFlyBehavior;
20  
21begin
22  Mallard := TMallardDuck.Create;
23  Mallard.PerformQuack;
24  Mallard.PerformFly;
25  FreeAndNil(Mallard);
26
27  Model := TModelDuck.Create;
28  Model.PerformFly;
29
30  FlyRocketPowered := TFlyRocketPowered.Create;
31  Model.SetFlyBehavior(FlyRocketPowered);
32  Model.PerformFly;
33  FlyRocketPowered := nil;
34  FreeAndNil(Model);
35
36  Readln;
37end.

运行结果:

时间: 2024-10-25 18:50:45

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---策略模式之MiniDuckSimulator[转]的相关文章

设计模式 ( 十九 ):Strategy策略模式 -- 行为型

设计模式 ( 十八 ) 策略模式Strategy(对象行为型) 1.概述 在软件开发中也常常遇到类似的情况,实现某一个功能有多种算法或者策略,我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能.如查找.排序等,一种常用的方法是硬编码(Hard Coding)在一个类中,如需要提供多种查找算法,可以将这些算法写到一个类中,在该类中提供多个方法,每一个方法对应一个具体的查找算法:当然也可以将这些查找算法封装在一个统一的方法中,通过if…else…或者case等条件判断语句来进行选择.这

设计模式之第8章-策略模式(Java实现)

设计模式之第8章-策略模式(Java实现) “年前大酬宾了啊,现在理发冲500送300,冲1000送500了.鱼哥赶紧充钱啊,理发这事基本一个月一回,挺实惠的啊.不过话说那个理发店的老板好傻啊,冲1000才送500,不如冲两次500,这样可以送600呢.”“这只能说明你不是很笨,但是也算不上聪明.”“啊?难道我想错了?”“这是一种策略,策略,懂?他如果是冲1000送700的话你是不是很大的可能性冲500?而不是1000,但是如果这样的话,在“聪明人”,对,没错,就是你这样的人来说,冲两次500表

设计模式(一)学习----策略模式

策略设计模式:定义一组算法,将每个算法都分装起来,并使他们之间可以互换. 策略模式就是使用的面向对象思想中的继承和多态的机制 策略模式的通用类图: Context类:Strategy类,并且和Strategy类是整体和个体的关系,即聚合关系.对策略角色个体进行封装. Strategy接口:定义这个策略或算法必须有的方法和属性. ConcreteStrategy1,ConcreteStrategy2具体策略角色实现类.实现抽象策略中的方法,该类中含有具体的算法. 上图变成Java代码: 抽象的策略

设计模式总结篇系列:策略模式(Strategy)

前面的博文中分别介绍了Java设计模式中的创建型模式和结构型模式.从本文开始,将分别介绍设计模式中的第三大类,行为型模式.首先我们了解下分为此三大类的依据. 创建型模式:主要侧重于对象的创建过程: 结构型模式:主要侧重于处理类或对象的组合: 行为型模式:主要侧重于类或对象之间的交互以及职责分配. 首先了解下策略模式的概念:定义了多个算法,并将它们封装起来(一般的是每个算法封装成一个单独的类),让算法独立于客户端而可以单独变化. 具体可以看一下下面的例子(以计算加.减.乘为例): 1. 对加.减.

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---工厂模式之简单工厂

简单工厂:工厂依据传进的参数创建相应的产品. http://www.cnblogs.com/DelphiDesignPatterns/archive/2009/07/24/1530536.html {<HeadFirst设计模式>工厂模式之简单工厂 } 3{ 产品类 } 4{ 编译工具 :Delphi7.0 } 5{ 联系方式 :[email protected]com } 6 7unit uProducts; 8 9interface 10 11type 12 TPizza = class(

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---迭代器模式之DinerMenu[转]

容器的主要职责有两个:存放元素和浏览元素.根据单一职责原则(SRP)要将二者分开,于是将浏览功能打包封装就有了迭代器. 用迭代器封装对动态数组的遍历:  1 2{<HeadFirst设计模式>之迭代器模式 } 3{ 容器中的元素类                  } 4{ 编译工具:Delphi7.0             } 5{ E-Mail :[email protected]     } 6 7unit uItem; 8 9interface1011type12  TMenuIte

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---模板方法模式之CoffeineBeverageWithHook[转]

模板方法模式定义了一个算法骨架,允许子类对算法的某个或某些步骤进行重写(override).   1  2{<HeadFirst设计模式>之模板方法模式 }  3{ 编译工具: Delphi7.0              }  4{ E-Mail : [email protected]      }  5  6unit uCoffeineBeverageWithHook;  7  8interface  9 10uses 11  SysUtils; 12 13type 14  TCoffei

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---命令模式之RemoteControlTest[转]

  1  2{<HeadFirst设计模式>之命令模式 }  3{ 本单元中的类为命令的接收者      }  4{ 编译工具 :Delphi7.0         }  5{ 联系方式 :[email protected] }  6  7unit uReceiveObject;  8  9interface 10 11type 12  TLight = class(TObject) 13  private 14    FLocation: String; 15  public 16    c

善用设计模式改善我们丑陋的代码——策略模式

有时候因为种种原因导致我们会写出很多丑陋的代码,比如赶工时,短暂性的偷懒,不会设计模式等等导致代码沉积,一个cs上万行代码这样场景是有发生, 当然这里也包括我...所以时间充裕一点之后就想重构一下,毕竟项目中的需求是不断变更的,面对需求变更,尽量做到最低限度的修改代码,最大化的扩充 新代码,还有一点就是不要过分的追求设计模式,做到适可为止,太设计模式了会导致类太多,不好管理,在项目开发中,其实仔细考虑一下,你会发现很多业 务逻辑都有相应的设计模式帮你优化,毕竟这些都是前辈们踩了无数的坑,经过无数