設計模式學習筆記-裝飾模式

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 運行結果

　　用拳腳攻擊！
　　步槍射擊，啪！
　　機槍掃射，突突突！
　　火箭炮射擊，唰......！