HeadFirst 设计模式- 装饰者模式

装饰者模式

动态的将责任附加到对象上，可以动态的对功能进行拓展。符合我们的对拓展开放，对修改关闭的原则。

装饰模式的角色分别为：

抽象组件：给出抽象接口，规范准备给附加对象的责任。

具体组件：定义一个要接收附加功能的类。

装饰角色：将组件组合进去以完成功能，并定义一个与抽象组件一致的接口。

具体装饰角色：负责给组件对象添加附加的责任。

 

所以通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。

代码如下：

//@by camel
//@date 2014/2/22

using System;
using System.Collections.Generic;
using System.Text;

namespace Decorator
{
    class Program
    {
        static void Main(string[] args)
        {
            Beverage beverage = new Espresso();
            Console.WriteLine("beverage cost :"+ beverage.cost());
            Beverage beverage2 = new Mocha(beverage);
            beverage2 = new Milk(beverage2);//能够利用基类中的方法不断的添加进新的组合对象。动态的加入
            Console.WriteLine("Cost is: " + beverage2.cost());
            Console.WriteLine("Description is :" + beverage2.getDescription());


            Console.ReadLine();
        }
    }
    abstract class Beverage//抽象组件，若只有一个基类，会产生过多的类，并且要对每一种新调料进行分析，
    {                      //因此更好的替代方法是动态的加入需要拓展的功能。
        public  String descprition = "Unknown Beverage";
        public abstract  String getDescription();
        public abstract double cost();
    }

    abstract  class CondimentDecorator : Beverage//装饰角色，可以在此加入新的方法。
    {
        public  Beverage beverage;//将组件组合进来
        public override String getDescription()//为了实现多态必须对父类进行重写。若不对父类进行重写，那么由Beverage传
        {                                     //入的对象将只能调用基类的getDescription.
            return descprition;
        }
    }

    class Espresso : Beverage//具体组件
    {
         public override String getDescription()//每个子类都应该实现此函数
        {
            return descprition;
        }
        public Espresso()//用以描述当前的对象
        {
            descprition = "Espresso";
        }
        public override double cost()
        {
            return 0.99;
        }
    }
    class Milk : CondimentDecorator//具体角色
    {
        public Milk(Beverage beverage)
        {
            this.beverage = beverage;
        }
        public override   String getDescription()//在对象中加入新的代码，相当于对原来的进行封装。
        {
            return beverage.getDescription() + " Milk";
        }

        public override double cost()//与抽象组件一样的责任。如果milk的价格发生改变，只需要将cost中的函数修改，
        {                            //基于milk的类就会一起发生改变。
            return 0.29 + beverage.cost();
        }


    }
    class Mocha : CondimentDecorator//具体角色
    {
        public Mocha(Beverage beverage)
        {
            this.beverage = beverage;
        }
        public override String getDescription()
        {
            return beverage.getDescription() + ", Mocha";
        }
        public override double cost()
        {
            return 0.2 + beverage.cost();
        }
    }
}

//在这里必须要说说C#中的抽象方法与虚函数之间的区别。
//将具体的类进行抽象成为抽象类，而接口则更多的是针对于某个行为，在C#中类的父类只有一个，但是可以实现多个接口
//虚函数必须实现。而抽象方法是不能够实现的，且不能创建实例。抽象方法可以实现多态、虚函数不然。
//抽象方法必须在子类中进行重写，而虚函数则不必。

运行效果：