设计模式二十四讲之《装饰模式》

定义： 动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
总结：1.装饰模式是为已有功能动态地添加更多功能的一种方式；
2.装饰模式把每个装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了；
3.把类中的装饰功能从类中搬移去除，这样可以简化原有的类；
4.有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中重复的装饰逻辑；
使用时机：需要通过继承的方法继承了被装饰类的类型，但是并没有继承被装饰类的行为，而是通过装饰者和组件组合的方式，重新定义了类的行为。类似角色系统中按角色划分后，还要给角色添加特殊属性时的创建，例如继承了基类角色的射手，战士等角色再装饰个属性控制类后添加不同的属性。

---

 class Program
    {
        static void Main(string[] args)
        {

            ConcreteCompent c = new ConcreteCompent();            //原始的装饰模式方法
            ConcreteDecoratorA d1 = new ConcreteDecoratorA();             //执行过程：1.先声明实例化ConcreteCompent对象，开辟内存地址；
            ConcreteDecoratorB d2 = new ConcreteDecoratorB();             //          2. d1.SetCompont(c)的方法将ConcreteCompent存储到ConcreteDecoratorA类的MComponent里；
                                                                          //          3. d2.SetCompont(d1)的方法将ConcreteDecoratorA存储到ConcreteDecoratorB类的MComponet里；
            d1.SetCompont(c);                                             //          4. d2.Operation()的方法先执行父类的Operation方法，由于之前的传递将父类的MComponet变成了ConcreteDecoratorB，故执行ConcreteDecoratorB的Operation方法，
            d2.SetCompont(d1);                                            //             而在执行ConcreteDecoratorB的Operation方法时又执行父类的Operation方法，且此时父类的MComponet变成了ConcreteDecoratorA，故又执行ConcreteDecoratorA
            d2.Operation();                                               //             的Operation方法，而在执行ConcreteDecoratorA的Operation方法时又执行了父类的Operation方法，且此时父类的MComponet变成了ConcreteCompent，故执行
                                                                          //             ConcreteCompent的Operation方法，这样层层执行，最终获得最后效果。
            Console.Read();



            Person xj = new Person("Legend");
            //Person xl = new Person("小刘");
            Console.WriteLine("\n 第一种打扮：");
            TShirts dtx = new TShirts();
            BigTrouser kk = new BigTrouser();

            dtx.Decorate (xj);
            kk.Decorate (dtx);
            kk.Show();

            Console.WriteLine("\n 第二种打扮");
            //这里没有写其他的服饰类，就先用这个意思一下
            kk.Decorate(xj);
            dtx.Decorate(kk);
            dtx.Show();
            Console.ReadKey();
        }
    }

---

abstract class MComponent
    {
        public abstract void Operation();

    }

    class ConcreteCompent : MComponent//这个类和Person那个类比较，就是将MComponet的抽象类整合到这个类里面了，就是没有了抽象类，直接以这个类作为父类
    {
        public override void Operation()
        {
            Console.WriteLine("具体对象的操作");
        }
    }
    abstract class Decorator : MComponent
    {
        protected MComponent mComponent;
        public void SetCompont(MComponent component)
        {
            this.mComponent = component;
        }
        public override void Operation()
        {
            if (mComponent != null)
            {
                mComponent.Operation();
            }
        }
    }

    class ConcreteDecoratorA : Decorator
    {
        private string addeState;
        public override void Operation()
        {
            base.Operation();
            addeState = "New State";
            Console.WriteLine("具体装饰对象A的操作");
        }
    }
    class ConcreteDecoratorB : Decorator
    {
        private string addeState;
        public override void Operation()
        {
            base.Operation();
            addeState = "New State";
            Console.WriteLine("具体装饰对象B的操作");
        }

        private void AddedBehaviod()//仅仅是用来区别ConcreteDecoratorA，表示多一个方法，没有其他意义
        {

        }
    }

---

 class Person
    {
        public Person()
        {

        }
        private string name;
        public Person(string name)
        {
            this.name = name;
        }
        public virtual  void Show()
        {
            Console.WriteLine("装扮的{0}",name);
        }
    }

---

 /// <summary>
    /// 服饰抽象类
    /// </summary>
   class Finery:Person  
    {
        protected Person component;      

        public void Decorate(Person component)
        {
            this.component = component;//按照执行逻辑，第一次先传递了xj的person进来，进行存储；第二次传递了dtx的person进来，进行存储；
        }
        public override  void Show()
        {
            if(component != null)
            {
                component.Show();
            }
        }
    }
    class TShirts : Finery
    {     
        public override void Show()
        {           
            Console.WriteLine("大T恤");//这里要留心base.show的放置位置，放在前面就是正向的显示，放在后面就是反向的显示
            base.Show();
        }
    }
    class BigTrouser : Finery
    {      
        public override void Show()//在执行show方法的时候，先执行了这里，然后通过base.show执行Finery中的show，由于之前第二次存储的是dtx的person，在TShirts类重写了show方法，所以执行TShirts类中的show方法，
                                   //然后又通过TShirts类中的show方法中的base.show又回到Finery中执行show方法，这时返回到第一次存储的xj的Person，由于没有重写，所以会执行父类Person中的show方法
                                   
                                   //总结：相当于每次执行都是回到Finery这个类中，通过装饰（Decorate）方法之前存储的“Person”，执行对应的Show方法
        {
            Console.WriteLine("垮裤");
            base.Show();
        }
    }

---

转载请注明出处!!!

欢迎加入951815219群聊，共享知识，讨论交流~