结构型模式：Decorator 装饰模式

                                                           结构型模式：Decorator 装饰模式

１、子类复子类，子类何其多
  １）假如咱们须要为游戏中开发一种坦克，除了各类不一样型号的坦克外，咱们还但愿在不一样场合中为其增长如下一种或多种功能：好比红外线夜视功能，好比水陆两栖功能，好比卫星定位功能等等。
  ２）这是游戏的设计坦克，所以这个定位要定位在软件的组件的设计。

//坦克抽象类
public abstract class Tank
{
  public abstract void Shot();
  public abstract void Run();
}
//各类型号
public class T50 : Tank
{
  //.....
}
public class T75 : Tank
{
  //.....
}
public class T90 : Tank
{
  //.....
}
//各类不一样功能的组合
public class T50A : T50, IA
{
  //......
}
public class T50B : T50, IB
{
  //......
}
public class T50C : T50, IC
{
  //......
}
public class T50AB : T50, IA, IB
{
  //......
}
public class T50BC : T50, IB, IC
{
  //......
}
public class T50ABC : T50, IA, IB, IC
{
  //......
}
......
  ３）分析：随着功能的扩展（各类功能的排列组合），子类会急剧膨胀。一个微小的变更就带来了很大的震动，
  这时候咱们引入了装饰（Decorator）模式解决这类问题。
 
２、动机（Motivation）
  １）上述描述的问题根源在于咱们“过分地使用了继承来扩展对象的功能”，因为继承为类型引入的静态特质，使得这种扩展方式缺少灵活性；而且随着子类的增多（扩展功能的增多），各类子类的组合（扩展功能的组合）会致使更多子类的膨胀（多继承）。
  ２）如何使“对象功能的扩展”可以根据须要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所致使 的影响将为最低？
 
３、意图（Intent）
  动态地给一个对象增长一些额外的职责（功能）。就增长功能而言，Decorator模式比生成子类更为灵活。
                                                                                     ——《设计模式》GoF
 
４、实例：扩展坦克在不一样场合下的功能
  １）下面用类继承的解决办法，扩展多种功，会致使子类过多
//坦克的抽象类
public abstract class Tank
{
  //各类功能
  public abstract void Shot();
  public abstract void Run();
}

//各类型号的坦克
public class T50 : Tank
{
  public override void Shot()
  {
  }
  public override void Run()
  {
  }
}

public class T75 : Tank
{
  public override void Shot()
  {
  }
  public override void Run()
  {
  }
}

public class T90 : Tank
{
  public override void Shot()
  {
  }
  public override void Run()
  {
  }
}

//扩展功能的接口
public interface IA
{
  //扩展功能
  void ShotA();
  void RunA();
}

public class T50 : Tank, IA
{
  private void IA.ShotA()
  {
  }
  private void IA.RunA()
  {
  }
 
  public override void Shot()
  {
    this.ShotA(); //功能扩展
    //do shot...
    base.Shot();
  }
 
  public override void Run()
  {
    this.RunA();//功能扩展
    //do run...
    base.Run();
  }
}

  ２）应用Decorator模式设计功能扩展
//坦克的抽象类
public abstract class Tank
{
  //各类功能
  public abstract void Shot();
  public abstract void Run();
}

//T50型号的坦克
public class T50 : Tank
{
  public override void Shot()
  {
  }
  public override void Run()
  {
  }
}

//扩展功能
public abstract class Decorator : Tank //实际是接口继承
{
  private Tank _tank;  //Has-A 对象组合
 
  public Decorator(Tank tank)
  {
    this._tank = tank;
  }
 
  public override void Shot()
  {
    _tank.Shot();
  }
 
  public override void Run()
  {
    _tank.Run();
  }
}

public class DecoratorA : Decorator
{
  //构造器是不继承的，要进行相应设置
  public DecoratorA(Tank tank) : base(tank)
  {
  }
 
  public override void Shot()
  {
    //红外功能扩展
    //do shot...
    base.Shot();
  }
 
  public override void Run()
  {
    //红外功能扩展
    //do run...
    base.Run();
  }
}

public class DecoratorB : Decorator
{
  //构造器是不继承的，要进行相应设置
  public DecoratorB(Tank tank) : base(tank)
  {
  }
 
  public override void Shot()
  {
    //水陆两栖功能扩展
    //do shot...
    base.Shot();
  }
 
  public override void Run()
  {
    //水陆两栖功能扩展
    //do run...
    base.Run();
  }
}

public class DecoratorC : Decorator
{
  //构造器是不继承的，要进行相应设置
  public DecoratorC(Tank tank) : base(tank)
  {
  }
 
  public override void Shot()
  {
    //卫星定位功能扩展
    //do shot...
    base.Shot();
  }
 
  public override void Run()
  {
    //卫星定位功能扩展
    //do run...
    base.Run();
  }
}

//客户程序
class App
{
  public static void Main()
  {
    Tank tank = new T50();
   
    DecoratorA da = new DecoratorA(tank);//红外
   
    DecoratorB db = new DecoratorB(da);//红外，两栖
   
    DecoratorC dc = new DecoratorB(db);//红外，两栖，卫星定位
  }
}

５、Decorator模式的几个要点   １）经过采用组合、而非继承的手法，Decorator模式实现了在运行时动态地扩展对象功能的能力，并且能够根据须要扩展多个功能。避免了单独使用继承带来的“灵活性差”和“多子类衍生问题”。   ２）Component类在Decorator模式中充当抽象接口的角色，不该该去实现具体的行为。并且Decorator类对于Component类应该透明——换言之Component类无需知道Decorator类，Decorator类是从外部来扩展Component类的功能。   ３）Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具备的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另一个Component类。咱们可使用一个   或者多个Decorator对象来“装饰”一个Component对象，且装饰后的对象仍然是一个Component对象。   ４）Decorator模式并不是解决“多子类衍生的多继承问题”，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。   ６、.NET框加中的Decorator应用 抽象接口：           Stream（流） 实体类：继承Stream           FileStream（文件流）           NetworkStream（网络流）           MemoryStrem（内存流） 装饰对象：继承Stream，内部还包括一个Stream字段           BufferedStream（缓冲功能扩展）           CryptoStream（加密功能扩展）