C# 设计模式系列教程-装饰模式

1. 概述

  动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更灵活。

  原理:增加一个修饰类包裹原来的类,包裹的方式一般是通过在将原来的对象作为修饰类的构造函数的参数。装饰类实现新的功能,但是,在不需要用到新功能的地方,它可以直接调用原来的类中的方法。修饰类必须和原来的类有相同的接口。

2. 模式中的角色

  2.1 抽象构建(Component):定义一个抽象接口,用以给这些对象动态地添加职责。

  2.2 具体构建(ConcreteComponent):定义一个具体的对象,也可以给这个对象添加一些职责。

  2.3 装饰类(Decorator): 装饰抽象类,继承了Component,从外类来扩展Component类的功能。

  2.4 具体装饰者(ConcretorDecorator):负责给构建对象添加职责。

3. 模式解读

  3.1 装饰模式的一般化类图

  3.2 装饰模式的一般化代码

 /// <summary>
 /// 定义一个对象接口,可以给这些对象动态地添加职责
 /// </summary>
 public abstract class Component
 {
  public abstract void Opration();
 }

 /// <summary>
 /// 具体对象
 /// </summary>
 public class ConcreteComponent:Component
 {

  public override void Opration()
  {
   // 具体对象的操作
  }
 }

 /// <summary>
 /// 抽象的装饰类,它不能初始化对象。
 /// </summary>
 public abstract class Decorator:Component
 {
  protected Component component;

  /// <summary>
  /// 设置Component
  /// </summary>
  /// <param name="component"></param>
  public void SetComponent(Component component)
  {
   this.component = component;
  }

  /// <summary>
  /// 重写Operation,实际执行的是Component的Operation。
  /// </summary>
  public override void Opration()
  {
   if (component != null)
   {
    component.Opration();
   }
  }
 }

 public class ConcreteDecoratorA : Decorator
 {
  private void SpecialOpration()
  {
   // 本类特有的功能
  }

  public override void Opration()
  {
   //首先运行原Component的Operation(),在执行本类的功能,相当于对原Component进行了装饰
   base.Opration();

   this.SpecialOpration();
  }
 }

 public class ConcreteDecoratorB : Decorator
 {
  private void SpecialOprationA()
  {
   // 本类特有的功能 A
  }

  private void SpecialOprationB()
  {
   // 本类特有的功能 B
  }

  public override void Opration()
  {
   //首先运行原Component的Operation(),在执行本类的功能,相当于对原Component进行了装饰
   base.Opration();

   this.SpecialOprationA();
   this.SpecialOprationB();
  }
 }

4. 模式总结

  4.1 优点

    4.1.1 每个装饰对象只关心自己的功能,不需要关心如何被添加到对象链当中。它是由Decorator的SetComponent方法来实现的,因而它们的职责是单一的。

    4.1.2 类的核心职责与动态添加的职责是分离的。如果再向主类中添加新的功能,一是违反了开放封闭原则,二是增加了主类的复杂度。

    4.1.3 比静态继承更灵活 与对象的静态继承相比,Decorator模式提供了更加灵活的向对象添加职责的方式,可以使用添加和分离的方法,用装饰在运行时刻增加和删除职责.

  4.2 缺点

    4.2.1 产生许多小对象,采用Decorator模式进行系统设计往往会产生许多看上去类似的小对象,这些对象仅仅在他们相互连接的方式上有所不同。

  4.3 适用场景

    4.3.1 当需要为已有功能动态地添加更多功能时。

    4.3.2 类的核心功能无需改变,只是需要添加新的功能时。

5. 应用实例:装备大兵!无任何装备时(核心功能)可以用拳脚搏击;装备了步枪,可以正常射击;装备了重机枪,可以扫射;装备了火箭筒,可以防空。

  5.1 类图设计

  5.2 代码实现

 /// <summary>
 /// 装备类,相当于Component
 /// </summary>
 public abstract class Equipment
 {

  public abstract void Attack();
 }

 /// <summary>
 /// 士兵类,继承自Equipment
 /// </summary>
 public class Soldier : Equipment
 {
  public Soldier()
  {
   // 构造函数
  }

  /// <summary>
  /// 没有任何武器装备下的核心功能
  /// </summary>
  public override void Attack()
  {
   Console.WriteLine("用拳脚攻击!");
  }
 }

 public abstract class EquipDecorator : Equipment
 {
  protected Equipment equipment;

  /// <summary>
  /// 增加装备,使用该方法来动态地给士兵增加装备
  /// </summary>
  /// <param name="equipment"></param>
  public void SetComponent(Equipment equipment)
  {
   this.equipment = equipment;
  }

  /// <summary>
  /// 攻击
  /// </summary>
  public override void Attack()
  {
   //如果有装备,就用装备进行攻击
   if (equipment != null)
   {
    equipment.Attack();
   }
  }
 }

 /// <summary>
 /// 步枪
 /// </summary>
 public class RifleEquipment : EquipDecorator
 {
  public override void Attack()
  {
   base.Attack();

   Console.WriteLine("步枪射击,啪!");
  }
 }

 /// <summary>
 /// 机枪
 /// </summary>
 public class MachineGunEquipment : EquipDecorator
 {
  public override void Attack()
  {
   base.Attack();

   Console.WriteLine("机枪扫射,突突突!");
  }
 }

 /// <summary>
 /// 火箭筒
 /// </summary>
 public class RocketGunEquipment : EquipDecorator
 {
  public override void Attack()
  {
   base.Attack();

   Console.WriteLine("火箭炮射击,唰......!");
  }
 }

  5.3 客户端调用

 class Program
 {
  static void Main(string[] args)
  {
   // 定义新兵
   Soldier soldier = new Soldier();

   // 三种装备
   RifleEquipment rifle = new RifleEquipment();
   MachineGunEquipment machineGun = new MachineGunEquipment();
   RocketGunEquipment rocketGun = new RocketGunEquipment();

   // 将三种装备全部交给新兵
   rifle.SetComponent(soldier);
   machineGun.SetComponent(rifle);
   rocketGun.SetComponent(machineGun);

   // 攻击,除了拳脚功夫外,新兵还可以使用步枪,机枪,火箭炮.最终执行的是rocketGun.Attack().
   rocketGun.Attack();

   Console.Read();
  }
 }

  5.4 运行结果

  用拳脚攻击!
  步枪射击,啪!
  机枪扫射,突突突!
  火箭炮射击,唰......!

以上就是本文的全部内容,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java设计模式之装饰模式(Decorator模式)介绍

    Decorator常被翻译成"装饰",我觉得翻译成"油漆工"更形象点,油漆工(decorator)是用来刷油漆的,那么被刷油漆的对象我们称decoratee.这两种实体在Decorator模式中是必须的. Decorator定义:动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活. 为什么使用Decorator 我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生

  • php设计模式 Decorator(装饰模式)

    复制代码 代码如下: <?php /** * 装饰模式 * * 动态的给一个对象添加一些额外的职责,就扩展功能而言比生成子类方式更为灵活 */ header("Content-type:text/html;charset=utf-8"); abstract class MessageBoardHandler { public function __construct(){} abstract public function filter($msg); } class Messag

  • .NET简单工厂模式讲解

    简单工厂模式介绍: 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 结构模式图: 角色分类: 工厂(Creator)角色 简单工厂模式的核心,它负责实现创建所有实例的内部逻辑.工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象. 抽象产品(Product)

  • C++设计模式之装饰模式

    前言 在实际开发时,你有没有碰到过这种问题:开发一个类,封装了一个对象的核心操作,而这些操作就是客户使用该类时都会去调用的操作:而有一些非核心的操作,可能会使用,也可能不会使用:现在该怎么办呢? 1.将这些非核心的操作全部放到类中,这样,一个类就包含了很多核心的操作和一些看似有关,但是又无关的操作:这就会使核心类发生"爆炸"的现象,从而使核心类失去了一定的价值,也使使用核心类的客户在核心操作和非核心操作中挣扎: 2.使用继承来扩展核心类,需要使用核心类时,直接建立核心类对象:当需要使用

  • java 装饰模式(Decorator Pattern)详解及实例代码

    装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 我们通过下面的实例来演示装饰器模式的使用.其中,我们将把一个形状装饰上不同的颜色,同时又不改变形状类. 实现 我们将创建一个 Shape 接口和实现了 Shape 接口的实体类.然后我们创建一个实现了 Shape 接口的抽象装饰类Sha

  • java 装饰模式(Decorator Pattern)详解

    装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 我们通过下面的实例来演示装饰器模式的使用.其中,我们将把一个形状装饰上不同的颜色,同时又不改变形状类. 实现 我们将创建一个 Shape 接口和实现了 Shape 接口的实体类.然后我们创建一个实现了 Shape 接口的抽象装饰类Sha

  • Ruby使用设计模式中的代理模式与装饰模式的代码实例

    代理模式 需求: 小明让小李替他追小丽(送洋娃娃,送花,送巧克力) 没有代理的代码: # -*- encoding: utf-8 -*- #追求者类 class Pursuit attr_accessor :mm def initialize(mm) @mm = mm end def give_dolls puts "#{mm.name} 送你洋娃娃" end def give_flowers puts "#{mm.name} 送你鲜花" end def give_

  • java设计模式之装饰模式详细介绍

    1.    装饰模式(Decorator)的定义:又名包装(Wrapper)模式,装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案. 2.    装饰模式以对客户端透明的方式动态的给一个对象附加上更多的责任.换言之客户端并不会觉的对象在装饰前和装饰后有什么区别. 3.    装饰模式可以在不创造更多的子类的模式下,将对象的功能加以扩展. 4.    装饰模式与类继承的区别: 1)    装饰模式是一种动态行为,对已经存在类进行随意组合,而类的继承是一种静态的行为,一个类定义成

  • .NET装饰模式讲解

    装饰模式的定义: 装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象. 装饰者模式结构图: 装饰者模式角色: (1)抽象构件(Component)角色:给出一个抽象接口,以规范准备接收附加责任的对象. (2)具体构件(Concrete Component)角色:定义一个将要接收附加责任的类. (3)装饰(Decorator)角色:持有一个构件(Component)对象的实例,并实现一个与抽象构件接口一致的接口. (4)具

  • 详解java装饰模式(Decorator Pattern)

    一.装饰器模式(Decorator Pattern) 允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 我们通过下面的实例来演示装饰器模式的使用.其中,我们将把一个形状装饰上不同的颜色,同时又不改变形状类. 二.实现 我们将创建一个 Shape 接口和实现了 Shape 接口的实体类.然后我们创建一个实现了 Shape 接口的抽象装

随机推荐