由浅入深大话设计模式——装饰模式

9 篇文章 2 订阅
7 篇文章 0 订阅

       今天我们从一个日常每个人都会接触的地方下手——换装,人靠衣服马靠鞍,衣服确实能提升一个人的外表分数(可是我就不会 = =),那如果让你做一个给人搭配不同衣服的系统你会怎么做呢?

 

下面我们设计一个程序:

class 装饰模式: MonoBehaviour
	{
		private void Start()
		{
			Person xc = new Person("小明");
			Debug.Log("\n 装扮:");
			xc.WearTShirts();
			xc.WearBigTrouser();
			xc.WearWearSneakers();
			xc.Show();
		}
	}
	class Person
	{
		private string name;
		public Person(string name)
		{
			this.name = name;
		}

		public void WearTShirts()
		{
			Debug.Log("大T恤");
		}
		public void WearBigTrouser()
		{
			Debug.Log("垮裤");
		}
		public void WearWearSneakers()
		{
			Debug.Log("破球鞋");
		}
		public void WearSuit()
		{
			Debug.Log("西装");
		}
		public void WearTie()
		{
			Debug.Log("领带");
		}
		public void WearLeatherShoes()
		{
			Debug.Log("皮鞋");
		}
		public void Show()
		{
			Debug.Log("装扮的"+name);
		}
	}

       这样每个人穿什么我们就可以搭配了,这样看上去是不是也还可以,那如果我们增加一个别的装扮呢,是不是要该Person中的逻辑,那么,我们就违背了开放-封闭原则,这里说一下这个原则的内容:

开放封闭原则:

1.对扩展开放;2.对更改封闭

是说软件实体(类,模块,函数等)应该可以扩展,但是不能修改

       那么我们是不是应该把每个方法分到不同的类中去管理,在调用就好了,就像这样:

class 装饰模式: MonoBehaviour
	{
		private void Start()
		{
			Person xc = new Person("小明");
			Debug.Log("\n 装扮:");
			Finery dtx = new TShirts();
			dtx.Show();
			xc.Show();
		
		}
	}
	class Person
	{
		private string name;
		public Person(string name)
		{
			this.name = name;
		}
		
		public void Show()
		{
			Debug.Log("装扮的"+name);
		}
	}
	abstract class Finery
	{
		public abstract void Show();
	}
	class TShirts : Finery
	{
		public override void Show()
		{
			Debug.Log("大T恤");
		}
	}
	//etc..各种类似类

       这样是把服装和人分开了,但是在Start函数中的逻辑还不是很简洁,就像你换衣服是在大庭广众之下换的一样,我们应该把他单独封装起来,在一个试衣间里换衣服才是合理地不是吗,那么我们就用到了装饰模式

装饰模式

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

                                                                   

class 装饰模式: MonoBehaviour
	{
		private void Start()
		{
			ConcreteComponent c = new ConcreteComponent();
			ConcreteDecoratorA d1 = new ConcreteDecoratorA();
			ConcreteDecoratorB d2 = new ConcreteDecoratorB();

			d1.SetComponent(c);
			d2.SetComponent(d1);
			d2.Operation();

		}
	}
	abstract class Component
	{
		public abstract void Operation();
	}
	class ConcreteComponent : Component
	{
		public override void Operation()
		{
			Debug.Log("具体对象的操作");
		}
	}
	abstract class Decorator : Component
	{
		protected Component component;
		public void SetComponent(Component component)
		{
			this.component = component;
		}
		public override void Operation()
		{
			if (component != null)
			{
				component.Operation();
			}
		}
	}
	class ConcreteDecoratorA : Decorator
	{
		private string addedState;
		public override void Operation()
		{
			base.Operation();
			addedState = "NewState";
			Debug.Log("具体装饰对象A的操作");
		}
	}
	class ConcreteDecoratorB : Decorator
	{
		private string addedState;
		public override void Operation()
		{
			base.Operation();
			addedState = "NewState";
			Debug.Log("具体装饰对象B的操作");
		}
	}

       有没有发现,其实装饰模式是利用SetComponent来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分开了,每个装饰对象只关心自己的功能,不需要关系如何被添加到对象链当中。

       那么,让我们把刚才的例子用装饰模式改动一下,这里有一个小改动

如果只有一个ConcreteComponent类而没有抽象的Component类,那么Decorator类可以是ConcreteComponent的一个子类。同样道理,如果只有一个ConcreteDecorator类,那么就咩有必要建立一个单纯的Decorator类,而可以把Decorator和ConcreteDecorator的责任合并成一个类。

class 装饰模式: MonoBehaviour
	{
		private void Start()
		{
			Person xc = new Person("小明");
			Debug.Log("装扮");
			TShirts dtx = new TShirts();
			BigTrouser kk = new BigTrouser();

			dtx.Decorate(xc);
			kk.Decorate(dtx);
			kk.Show();
		}
	}
	class Person 
	{
		public Person()
		{

		}
		private string name;
		public Person(string name)
		{
			this.name = name;
		}
		public virtual void Show()
		{
			Debug.Log("装扮的"+name);
		}

	}
	abstract 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()
		{
			Debug.Log("大T恤");
			base.Show();
		}
	}
	class BigTrouser : Finery
	{
		public override void Show()
		{
			Debug.Log("垮裤");
			base.Show();
		}
	}
	//其余类似

完成!!今天你学废了吗!

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 《设计模式之禅第3版pdf》是一本介绍设计模式的书籍,是作者秦小波总结多年编程和软件开发实践的经验而得出的结论。该书提供了许多实用的设计模式,这些模式可以帮助开发人员更好地编写可维护、可扩展和可重用的代码。 该书首先介绍了设计模式的基本概念和原则,例如SOLID原则和GRASP原则,然后详细介绍了23种常见的设计模式,包括创建型、结构型和行为型模式。 该书的优点在于,它不仅提供了许多具体的代码示例和实际应用场景,还深入解释了每个模式的原理和适用条件。此外,该书还提供了设计模式的演化历程,以及如何使用UML图形表示不同的模式。 虽然该书提供了丰富的知识,但它并不是一本初学者可以轻松掌握的书籍。初学者可能需要花费很多时间和精力来理解书中的概念和代码实例。与此同时,该书的代码示例使用Java语言,因此对于非Java开发人员可能需要适当地进行转换。 综上所述,《设计模式之禅第3版pdf》是一本非常有价值的设计模式书籍,对于希望提高代码质量和扩展性的开发人员来说,是一本必读之作。 ### 回答2: 《设计模式之禅第3版》是一本关于对象设计模式的经典著作,是程序员学习设计模式的一本不可或缺的参考书。该书共分为3部分,包含了23种设计模式,并以生动的例子和详细的代码展示了如何应用各种设计模式解决实际问题。 第一部分介绍了7种创建型模式,这些模式主要用于创建对象。其中包括了工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式、享元模式和对象池模式。通过这一部分的学习,读者可以了解到如何灵活地创建对象,避免了对象创建过程中出现的一些问题。 第二部分介绍了11种结构型模式,这些模式主要用于组织类和对象。其中包括了适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式、代理模式、管道过滤器模式、私有类数据模式、模板方法模式和访问者模式。通过这一部分的学习,读者可以学会如何组织各种不同类和对象之间的关系,从而更加有条理地编写代码。 第三部分介绍了5种行为型模式,这些模式主要用于管理对象之间的交互和职责。其中包括了责任链模式、命令模式、解释器模式、迭代器模式和观察者模式。通过这一部分的学习,读者可以学会如何精确地定义对象之间的互动和职责,从而更好地解决实际问题。 总体而言,《设计模式之禅第3版》由浅入深,结构清晰,用通俗易懂的语言阐述了设计模式的本质和应用,是程序员进行设计模式学习和应用的一本宝典。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值