Decorator模式学习

using System;

namespace Decorator
{
 abstract class Tank
 {
  abstract void Shot();
  abstract void Run();
 }
 public class T50:Tank
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }
 }
 public class T75:Tank
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }
 }
 public class T90:Tank
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }
 }
 public interface IA
 {
  void ShotA();
  void RunA();
 }

 public class T50A:Tank,IA
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }

  private void ShotA()
  {
   // TODO:  添加 T50A.ShotA 实现
  }

  private void RunA()
  {
   // TODO:  添加 T50A.RunA 实现
  }
 }
 public class T75A:Tank,IA
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }

  private void ShotA()
  {
   // TODO:  添加 T75.ShotA 实现
  }

  private void RunA()
  {
   // TODO:  添加 T75.RunA 实现
  }
 }
 public class T90A:Tank,IA
 {
  public override void Short()
  {
  }
  public override void Run()
  {
  }
  private void ShotA()
  {
   // TODO:  添加 T90.ShotA 实现
  }

  private void RunA()
  {
   // TODO:  添加 T90.RunA 实现
  }
 }
}

namespace Decorator2
{
 public abstract class Tank
 {
  abstract void Shot();
  abstract void Run();
 }

 /// <summary>
 /// 抽象装饰类
 /// </summary>
 public abstract class Decorator:Tank//Do As接口继承
 {
  private Tank _tank;//Has-A对象组合

  public Decorator(Tank tank)
  {
   _tank=tank;
  }
  public  override void Shot()
  {
   _tank.Shot();
  }
  public override void Run()
  {
   _tank.Run();
  }
 }

 /// <summary>
 /// 下面A、B、C三个类是装饰类
 /// 装饰类的特点是“is a , has a”即继承Tank又包含一个Tank对象
 /// </summary>

 /// <summary>
 /// 红外功能
 /// </summary>
 public class DecoratorA:Decorator
 {
  public DecoratorA(Tank tank)
   :base(tank)
  {
  }
  public override void Shot()
  {
   //do some extension功能扩展

   //do shot..
   base.Shot();
  }
  public override void Run()
  {
   //do some extension功能扩展

   //do run..
   base.Run();
  }
 }

 /// <summary>
 /// 水路两栖
 /// </summary>
 public class DecoratorB:Decorator
 {
  public DecoratorB(Tank tank)
   :base(tank)
  {
  }
  public override void Shot()
  {
   //do some extension功能扩展

   //do shot..
   base.Shot();
  }
  public override void Run()
  {
   //do some extension功能扩展

   //do run..
   base.Run();
  }
 }

 /// <summary>
 /// 卫星定位
 /// </summary>
 public class DecoratorC:Decorator
 {
  public DecoratorC(Tank tank)
   :base(tank)
  {
  }
  public override void Shot()
  {
   //do some extension功能扩展

   //do shot..
   base.Shot();
  }
  public override void Run()
  {
   //do some extension功能扩展

   //do run..
   base.Run();
  }
 }

 /// <summary>
 /// /
 /// </summary>

 public class T50:Tank
 {
  public override void Shot()
  {
  }
  public override void Run()
  {
  }
 }
 
 /// <summary>
 ///一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆性增长。
///另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类
///类爆炸”还只是现象，“类爆炸”的产生是由于某些类在多个维度或者说多个方向上的变化而造成的。
 /// 多继承可以作为一个“经验性的判断”来使用Decorator模式，但
 /// 应用要点绝非在此，而是解决“主体类（Tank）在多个方向上的扩展功能（Decorator）”的问题
 /// Decorator（扩展功能）的实质是一个Tank类的子类
 ///
 /// </summary>
 public class  App
 {
  public static void main()
  {
   Tank tank=new T50();

   //对象组合方案
   //通过采用组合而非继承的手法，Decorator模式实现了在运行时动态地扩展对象功能的能力
   //而且可以根据需要扩展多个功能，避免了单独使用继承带来的“灵活性差”和“多子类衍生问题”
   DecoratorA da=new DecoratorA(tank);//红外
   DecoratorB db=new DecoratorB(da);//红外、两栖
   DecoratorC dc=new DecoratorB(db);//红外、两栖、卫星定位

   dc.Shot();
  }
 }
}

转载于:https://www.cnblogs.com/kuailewangzi1212/archive/2006/03/10/347393.html