大话设计模式，让你的代码更完美2---嵌套装饰模式

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

abstract class Finery
{
public abstract void Show();
}

服饰抽象类的实现类：

//大T恤
class TShirts : Finery
{
public override void Show()
{
Console.Write("大T恤 ");
}
}
//垮裤
class BigTrouser : Finery
{
public override void Show()
{
Console.Write("垮裤 ");
}
}

主函数代码：

static void Main(string[] args)
{
Person xc = new Person("小菜");
Console.WriteLine("\n第一种装扮：");
Finery dtx = new TShirts();
Finery kk = new BigTrouser();
Finery pqx = new Sneakers();
dtx.Show();
kk.Show();
pqx.Show();
xc.Show();
Console.Read();
}

菜鸟的代码很简单，但是调用起来很复杂，菜鸟代码中创建了一个服饰抽象类（该抽象类规定其实现类必须打印其服饰类型，即show方法），

并用两个实体（T恤，垮裤）类去实现服饰抽象类。然后再在主函数中调用，你会发现person和服饰类没有联系。

这样写的话感觉不是很舒服，因为服饰类和person没有关系，那么还不如直接在主函数中打印一个人名，再调用服饰类的show方法，节省一个person类不是吗？

老鸟代码：

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

class Finery : Person
{
protected Person component;
//打扮
public void Decorate(Person component)
{
this.component = component;
}
public override void Show()
{
if (component != null)
{
component.Show();
}
}
}

class TShirts : Finery
{
public override void Show()
{
Console.Write("大T恤 ");
base.Show();
}
}
class BigTrouser : Finery
{
public override void Show()
{
Console.Write("垮裤 ");
base.Show();
}
}   
class Sneakers : Finery
    {
        public override void Show()
        {
            Console.Write("破球鞋 ");
            base.Show();
        }
    }

Person xc = new Person("小菜");
Console.WriteLine("\n第一种装扮：");
Sneakers pqx = new Sneakers();
BigTrouser kk = new BigTrouser();
TShirts dtx = new TShirts();
pqx.Decorate(xc);
kk.Decorate(pqx);
dtx.Decorate(kk);
dtx.Show();

老鸟的代码对菜鸟的代码进行改进，让person类和服饰类的进行挂钩，即服饰类继承了person类，服饰要和指定的person搭配。于是就有了上述代码，

创建一个person，然后将person分别传给每种服饰，即该person拥有了上述的服饰。

看不懂代码？可以调试嘛~
调试过程如下：
1.首先把Person传入到Sneaker（鞋）对象中
2.把Sneaker（鞋）对象传入到BigTrouser（裤子）对象中
3.把BigTrouser（裤子）对象传入到TShirts（T恤）对象中
以上三步都会走Finery（装饰）对象中得Decorate（打扮）方法，因为Person是Finery（装饰）类的父类，
Finery（装饰）类是TShirts（装饰物等）的父类，所以在Decorate方法获取到的都是人（可以理解为传入之前都是猫，狗，现在统一用动物调用）
4.最后穿上的是T恤，所以这时候才能去展示Person穿的衣服。

总结，

Person传入到Sneaker对象，Sneaker对象传入到Big对象，Big对象传入到TShirt对象（先有人及其名字，然后穿上鞋子，穿裤子，穿完裤子穿T恤），

提示1，当将person传入到Sneaker对象中是，Sneaker中是找不到Decorate方法的，所以会去父类中找该方法。

提示2，当将Sneaker传入到BigTrouser对象中时，因为两者都继承了person类，所以会自动将Sneaker转换为person类，

并将转换过的person放入到BigTrouser对象中的Component中，这里和多态有关，通俗的将就是将猫转为动物，因为不知道传入的动物是什么动物，就统一用动物进行称呼调用，

然后调用的时候就会发现，哦，这个动物是猫，所以其后的show打印的内容是该服饰。（这里用了动物和猫，来解释多态）

而调用的show方法的时候他是倒着来打印的（先打印T恤，在打印裤子，再打印鞋子，最后打印名字）。

注意，服饰类的实现类和person是继承关系，所以传递的时候是没有问题。

菜鸟的代码只使用了抽象类，甚至有的菜鸟抽象类都不用，这里将菜鸟和老鸟的代码进行对比目的是使得编码者改进自己的代码。

即利用继承的特性，让邋里邋遢的张三（赤果果）依次挑了3件衣服（挑取鞋，裤子，T恤按照进栈，穿衣服（打印）的话按照出栈的方式），
穿完衣服后，我们大声惊呼，哇，张三穿完衣服后就是不一样，果然是人靠衣服佛靠装！