意图/目的/定义（intent）

（简短的描述该模式的作用。）
策略模式定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

动机（motivation）

（动机给出来问题以及如何解决这个问题的具体场景。）

适用性（applicability）

（适用性描述模式可以被应用在什么场合。）

结构（structure）

（结构提供了图示，显示出参与此模式的类之间的关系。）

参与者（participants）

（参与者描述在此设计中所涉及到的类和对象在模式中的责任和角色。）

协作（collaborations）

（协作告诉我们参与者如何在此模式中合作。）

实现/范例代码（implementation/sample code）

（实现提供了你在实现该模式时需要使用的技巧，以及你应该小心面对的问题。）
（范例代码提供代码的片段，可能对你的实现有多帮助。）
模拟鸭子类型实现代码

  2. /// 飞行行为超类
  3. abstract class FlyBehavior {
  4.   void fly();
  5. }
  7. // 翅膀飞行
  8. class FlyWithWings extends FlyBehavior {
  9.   void fly() {
  10.     print('使用翅膀飞行');
  11.   }
  12. }
  14. /// 不会飞行
  15. class FlyNoWay extends FlyBehavior {
  16.   void fly() {
  17.     print('不会飞');
  18.   }
  19. }
  21. /// 叫声行为类
  22. abstract class QuackBehavior {
  23.   void quack();
  24. }
  26. /// 呱呱叫
  27. class Quack extends QuackBehavior {
  28.   void quack() {
  29.     print('呱呱叫');
  30.   }
  31. }
  33. /// 吱吱叫
  34. class Squeak extends QuackBehavior {
  35.   void quack() {
  36.     print('吱吱叫');
  37.   }
  38. }
  40. /// 不会叫
  41. class MuteQuack extends QuackBehavior {
  42.   void quack() {
  43.     print('不会叫');
  44.   }
  45. }
  47. /// 鸭子类
  48. abstract class Duck {
  49.   FlyBehavior flyBehavior;
  50.   QuackBehavior quackBehavior;
  52.   // 构造函数
  53.   Duck(this.flyBehavior, this.quackBehavior);
  54.   // Duck(fb, qb) {
  55.   //   this.flyBehavior = fb;
  56.   //   this.quackBehavior = qb;
  57.   // }
  59.   // 外观
  60.   void display();
  62.   // 飞行
  63.   void performFly() {
  64.     flyBehavior.fly();
  65.   }
  67.   // 叫声
  68.   void performQuack() {
  69.     quackBehavior.quack();
  70.   }
  72.   void setFly(FlyBehavior fb) {
  73.     this.flyBehavior = fb;
  74.   }
  76.   void setQuack(QuackBehavior qb) {
  77.     this.quackBehavior = qb;
  78.   }
  80.   // 游泳
  81.   void swim() {
  82.     print('游泳');
  83.   }
  84. }
  86. /// 野鸭
  87. class MallardDuck extends Duck {
  88.   MallardDuck()
  89.       : super(
  90.           new FlyWithWings(),
  91.           new Quack(),
  92.         );
  94.   @override
  95.   void display() {
  96.     print('我是野鸭');
  97.   }
  98. }
  100. /// 红头鸭
  101. class RedheadDuck extends Duck {
  102.   RedheadDuck()
  103.       : super(
  104.           new FlyWithWings(),
  105.           new Quack(),
  106.         );
  108.   @override
  109.   void display() {
  110.     print('红头鸭');
  111.   }
  112. }
  114. /// 橡皮鸭
  115. class RubberDuck extends Duck {
  116.   RubberDuck()
  117.       : super(
  118.           new FlyNoWay(),
  119.           new Squeak(),
  120.         );
  122.   @override
  123.   void display() {
  124.     print('橡皮鸭');
  125.   }
  126. }
  128. /// 测试
  129. void main() {
  130.   MallardDuck mallardDuck = new MallardDuck();
  131.   RedheadDuck redheadDuck = new RedheadDuck();
  132.   RubberDuck rubberDuck = new RubberDuck();
  134.   mallardDuck.display();
  135.   mallardDuck.swim();
  136.   mallardDuck.performFly();
  137.   mallardDuck.performQuack();
  138.   print('\n');
  140.   redheadDuck.display();
  141.   redheadDuck.swim();
  142.   redheadDuck.performFly();
  143.   redheadDuck.performQuack();
  144.   print('\n');
  146.   rubberDuck.display();
  147.   rubberDuck.swim();
  148.   rubberDuck.performFly();
  149.   rubberDuck.performQuack();
  150.   print('\n');
  152.   // 动态设置鸭子行为
  153.   print('动态设置鸭子行为后：');
  154.   mallardDuck.setFly(new FlyNoWay());
  155.   mallardDuck.setQuack(new MuteQuack());
  156.   mallardDuck.display();
  157.   mallardDuck.swim();
  158.   mallardDuck.performFly();
  159.   mallardDuck.performQuack();
  160. }

已知应用（known uses）

（已知应用用来描述已经在真实系统中发现的模式例子。）

相关模式（related patterns）

（相关模式描述了此模式和其他模式之间的关系。）

OO知识

OO基础

  1. 抽象
  2. 封装
  3. 多态
  4. 继承

OO原则

  1. 封装变化
  2. 多用组合少用继承

  3. 针对接口编程，不针对实现编程

    要点

  4. 知道OO基础，并不足以让你设计出良好的OO系统。

  5. 良好的OO设计必须具备可复用、可扩展、可维护三个特性。
  6. 模式可以让我们建造出具有良好OO设计质量的系统。
  7. 模式被认为是历经验证的OO设计经验。
  8. 模式不是代码，而是针对设计问题的通用解决方案。你可以把他们应用到特定的应用中。
  9. 模式不是被发明，而是被发现。
  10. 大多数的模式和原则，都着眼于软件变化的主题。
  11. 大多数的模式都允许系统局部改变独立于其他部分。
  12. 我们常把系统中会变化的部分抽出来封装。
  13. 模式让开发人员之间有共享的语言，能够最大化沟通的价值。