设计模式(四)一文搞明白装饰者模式

  • 一文带你搞懂Java动态代理
  • 几分钟带你搞懂策略模式
  • 几分钟带你搞懂观察者模式
  • 一文彻底搞明白工厂和抽象工厂
  • 一文搞明白装饰者模式
  • 最全单例模式
  • 几段代码搞明白命令模式
  • 几段代码搞明白适配器模式
  • 一看就懂的外观模式
  • 一看就懂的模版方法模式
  • 几段代码搞懂迭代器模式
  • 一文搞懂明白状态模式

关于装饰者模式的定义,我就直接引用Head First了:装饰者模式动态的将责任附加到对象上。若要扩展功能,装饰者提供了比继承更有弹性的替代方案 。 其实装饰者模式的重点在于给对象动态的附加职责,通过对象组合的方式,运行时装饰对象,在不改变任何底层代码的情况下,给现有对象赋予新的职责。

装饰者模式

现在我们要为卖煎饼的大妈设计一套系统,让大妈能更好的算账收钱。大妈主要经营煎饼(7元),并可以往其中添加配料烤肠(1元),鸡蛋(1元),如果生意红火,可能会考虑扩大经营其他小吃或添加配料种类。现需要设计出一套系统,以便快速计算出每位顾客所购小吃的价格。

这是一个食品类接口。同样,要符合针对接口编程,不针对实现编程的OO原则。

public interface ISnack {
	// 食物的描述
	String getDescription();
	// 食物的价格
	double cost();
}

这是一个配料类接口。配料类接口IDecoratorSnack继承自ISnack接口,因为需要两接口的实现类(装饰者与被装饰对象)具有相同的超类型,只有这样IDecoratorSnack接口才能取代ISnack接口。

/**
 * 这是配料类的接口。
 * 
 * 

装饰者与被装饰者需要具有相同的接口, * 这样用户使用装饰者对象才会和使用原始对象一样。 */ public interface IDecoratorSnack extends ISnack { // 可根据需要扩展属性,如配料大份,小份等 }

这是具体的食品-煎饼类

public class PancakeSnack implements ISnack {
	@Override
	public String getDescription() {
		return "煎饼";
	}
	
	@Override
	public double cost() {
		return Price.PancakeSnack.price;
	}
}

食品类(被装饰者)既可以单独使用,也可以被配料类(装饰者)包着使用,因为装饰者和被装饰者对象具有相同的超类型,所以在任何需要原始对象(被包装的)的场合,都可以用装饰过的对象替代它

如果,我想要一份加鸡蛋和烤肠的煎饼价格是多少?单价类见下:

public enum Price {
	//鸡蛋、烤肠、煎饼
	Egg(1.0), Sausage(1.0), PancakeSnack(7.0);
	
	double price;

	private Price(double price) {
		this.price = price;
	}
}

这是我们的具体配料鸡蛋类

public class Egg implements IDecoratorSnack {
	// 持有被修饰的对象
	ISnack iSnack;
	
	public Egg(ISnack iSnack) {
		this.iSnack = iSnack;
	}
	
	@Override
	public String getDescription() {
		return iSnack.getDescription() + ",加鸡蛋";
	}
	
	@Override
	public double cost() {
	    // 被修饰对象的价格 + 鸡蛋价格
		return iSnack.cost() + Price.Egg.price;
	}
}

这是具体的烤肠配料类

public class Sausage implements IDecoratorSnack{
	//持有被修饰对象的引用
	ISnack iSnack;
	
	public Sausage(ISnack iSnack) {
		this.iSnack = iSnack;
	}
	
	@Override
	public String getDescription() {
		return iSnack.getDescription() + ",加香肠";
	}
	
	@Override
	public double cost() {
		// 被修饰对象的价格 + 烤肠价格
		return iSnack.cost() + Price.Sausage.price;
	}
}

每个装饰者都持有一个被装饰者的对象,这个被装饰者对象不一定是原始对象,也可能是被包装了多层的对象。通过这种组合,加入了新的行为。符合对扩展开放,对修改关闭的OO原则

我们来收钱吧。我们能够发现,我们能够使用被装饰的对象就像使用原始对象一样,这归功于装饰者与被装饰者具备同样的接口。同样一个原始对象是能够被包装多层的,而在使用者的眼里,它只是一个被赋予了新功能的原始对象而已。

public class DecoratorPatternTest {
	
	public static void main(String[] ags) {
        // 煎饼 + 鸡蛋 + 烤肠
		ISnack snackOneISnack = new PancakeSnack();
		snackOneISnack = new Egg(snackOneISnack);
		snackOneISnack = new Sausage(snackOneISnack);
		// 这样就能够打印出,我们的(煎饼 + 鸡蛋 + 烤肠)价格和描述了
		System.out.println(snackOneISnack.getDescription() + "价格:" + snackOneISnack.cost() + "元");
	}
}

而且扩展起来方便,我们随时加入不同种类小吃和配料类。如我们现在要加一种烤冷面类

public class ColdRoastSnake implements ISnack{
	@Override
	public String getDescription() {
		return "烤冷面";
	}
	
	@Override
	public double cost() {
		return Price.ColdRoastSnake.price;
	}
}

我们再添加一个鸡里脊肉类

public class Chicken implements IDecoratorSnack{	
	ISnack iSnack;
	
	public Chicken(ISnack iSnack) {
		this.iSnack = iSnack;
	}
	
	@Override
	public String getDescription() {
		return iSnack.getDescription() + ",加里脊肉";
	}
	
	@Override
	public double cost() {
		return iSnack.cost() + Price.Chicken.price;
	}
}

好了,如果用户购买烤冷面+鸡蛋+里脊肉,价格该多少呢?

public class DecoratorPatternTest {
	
	public static void main(String[] ags) {
        // 烤冷面 + 鸡蛋 + 里脊肉
		ISnack snackOneISnack = new ColdRoastSnake();
		snackOneISnack = new Egg(snackOneISnack);
		snackOneISnack = new Chicken(snackOneISnack);
		// 这样就能够打印出,我们的(烤冷面 + 鸡蛋 + 里脊肉)价格和描述了
		System.out.println(snackOneISnack.getDescription() + "价格:" + snackOneISnack.cost() + "元");
	}
}

需要注意的是,通过利用装饰者模式,会造成设计中产生大量的小类,如果过度使用,会使程序变得很复杂。另外可能还会出现类型问题,如果把代码写成依赖于具体的被装饰者类型,不针对抽象接口进行编程,那么就会出现问题。

你可能感兴趣的:(模式架构)