七、设计模式——装饰模式

咖啡馆订单系统项目

1)咖啡种类:Espresso、ShortBlack、LongBlack、Decaf

2)调料:Milk、Soy、Chocolate

3)扩展性好、方便改动、方便维护

单品的咖啡通过调料混合成卖品。



OO设计方案



定义一个抽象的超类,Drink作为所有咖啡的父类。

咋一看好像能够满足需求,可是仔细推敲,如果加奶的咖啡这种情形怎么表示?或者加奶+巧克力+豆浆的咖啡呢?

这将会是噩梦,因为由此扩展开来的类将会很多很多。

另一个思路,既然每种单品都可以加配料,那么在超类中提供用布尔类型来标记哪些配料需要增加。

分别用三个字段isMilk , isSoy ,isChocolate,子类通过set方法来指定单品需加哪些配料。

这样能够解决类暴炸的问题,我们可以在cost中使用switch来决定结算的价格。

但是这又有扩展性的问题,如果有新调料增加,就必须修改超类。



装饰者模式



装饰者模式像打包快递。

1)有主体 :一个

2)有包装:多层

装饰者模式:动态的将新功能附加到对象上。

装饰层需要持有主体,在自己的方法中加入包装的操作与主体的操作一起完成功能。我自己也晕了...

以下是主体类:

public abstract class Drink {
	public String description="";
	private float price=0f;;
	public void setDescription(String description)
	{
		this.description=description;
	}
	public String getDescription()
	{
		return description+"-"+this.getPrice();
	}
	public float getPrice()
	{
		return price;
	}
	public void setPrice(float price)
	{
		this.price=price;
	}
	public abstract float cost();
}

public  class Coffee extends Drink {
	@Override
	public float cost() {
		return super.getPrice();
	}
}

public class Decaf extends Coffee {
	public Decaf()
	{
		super.setDescription("Decaf");
		super.setPrice(3.0f);
	}
}

public class LongBlack extends Coffee{
	public LongBlack()
	{
		super.setDescription("LongBlack");
		super.setPrice(6.0f);
	}
}

装饰部分:

public  class Decorator extends Drink {
	private Drink Obj;
	public Decorator(Drink Obj){
		this.Obj=Obj;
	};
	@Override
	public float cost() {
		return super.getPrice()+Obj.cost();
	}
	@Override
	public String getDescription()
	{
		return super.description+"-"+super.getPrice()+"&&"+Obj.getDescription();
	}
}

public class Chocolate extends Decorator {
	public Chocolate(Drink Obj) {
		super(Obj);
		super.setDescription("Chocolate");
		super.setPrice(3.0f);
	}
}

public class Milk extends Decorator {
	public Milk(Drink Obj) {
		super(Obj);
		super.setDescription("Milk");
		super.setPrice(2.0f);
	}
}

测试代码:

public class CoffeeBar {
	public static void main(String[] args) {
		Drink order;
		order=new Decaf();
		System.out.println("order1 price:"+order.cost());
		System.out.println("order1 desc:"+order.getDescription());

		System.out.println("****************");
		order=new LongBlack();
		order=new Milk(order);
		order=new Chocolate(order);
		order=new Chocolate(order);
		System.out.println("order2 price:"+order.cost());
		System.out.println("order2 desc:"+order.getDescription());
	}
}

运行结果:

order1 price:3.0
order1 desc:Decaf-3.0
****************
order2 price:14.0
order2 desc:Chocolate-3.0&&Chocolate-3.0&&Milk-2.0&&LongBlack-6.0
时间: 2024-11-07 18:25:28

七、设计模式——装饰模式的相关文章

c++设计模式----装饰模式

前言 在实际开发时,你有没有碰到过这种问题:开发一个类,封装了一个对象的核心操作,而这些操作就是客户使用该类时都会去调用的操作:而有一些非核心的操作,可能会使用,也可能不会使用:现在该怎么办呢? 将这些非核心的操作全部放到类中,这样,一个类就包含了很多核心的操作和一些看似有关,但是又无关的操作:这就会使核心类发生"爆炸"的现象,从而使核心类失去了一定的价值,也使使用核心类的客户在核心操作和非核心操作中挣扎: 使用继承来扩展核心类,需要使用核心类时,直接建立核心类对象:当需要使用核心类扩

设计模式——装饰模式(Decorator)

要想正确理解设计模式,首先必须明确它是为了解决什么问题而提出来的. 设计模式学习笔记 --Shulin 转载请注明出处:http://blog.csdn.net/zhshulin 1.概念 装饰模式又名包装(Wrapper)模式.装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案. 但是纯粹的装饰模式很难找到,大多数的装饰模式的实现都是"半透明"的,而不是完全透明的.换言之,允许装饰模式改变接口,增加新的方法.半透明的装饰模式是介于装饰模式和适配器模式之间的.适配器模

设计模式—装饰模式和适配器模式

装饰模式又名包装(Wrapper)模式.装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案. 设计模式在JAVA I/O库中的应用 装饰模式在Java语言中的最著名的应用莫过于Java I/O标准库的设计了. 由于Java I/O库需要很多性能的各种组合,如果这些性能都是用继承的方法实现的,那么每一种组合都需要一个类,这样就会造成大量性能重复的类出现. 而如果采用装饰模式,那么类的数目就会大大减少,性能的重复也可以减至最少.因此装饰模式是Java I/O库的基本模式. 适配器模

将计算机思维故事化——之设计模式装饰模式

"我要买一个装东西的袋子" --如果需要搬家里的行李,这句话可能会发生在超市里. 那么,上述提到的三个名词--"东西"."袋子"和"行李",应该是如下图关系: (1)行李,是一样东西 (2)袋子,也是一样东西 (3)袋子,可以装行李 通过以上三句话的关系,可以得出结论:第一,袋子可以装东西,虽然其本身就是一样东西:第二,装了东西的袋子,还是一样东西.所以,可以在行李的基础上,不断地套袋子,且不管加多少层,最后得到的还是一样东西

大话设计模式-装饰模式(C++)

<大话设计模式>的装饰模式的C++实现. 结构图: Decorator.h: #ifndef _DECORATOR_H #define _DECORATOR_H #include <iostream> #include <string> using namespace std; //ConcreteComponent类 class CPerson { public: CPerson(){}; CPerson(string str):m_sName(str){}; vir

小菜学设计模式——装饰模式

背景 很多时候你会发现子类在不断增加,有时候甚至难以控制,虽然继承是面向对象的一大特征,但是继承并不是项目中所提倡,合成复用设计原则就告诉我们能够使用合成的地方尽量不要使用继承.对于继承来说还有一个很大的缺点,那就是内存占用与子类的层次是成正比关系的,这个也很好理解,实例化子类的时候总是要先调用最顶层父类的构造方法,然后依次调用低层次的父类直到自身初始化,这个过程实际上是很耗内存的.那么,问题就来了,我们经常会扩展一个类的某个方法,是不是没扩展方法都有必要新增一个子类呢?答案是否定的,在某种情况

大话设计模式—装饰模式

装饰模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 大话设计模式中程杰老师给出的定义,装饰模式:动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更加灵活. 装饰模式结构图如下: 关键代码: 1.Component 类充当抽象角色,不应该具体实现. 2.修饰类引用和继承

Java设计模式----装饰模式

1.概念: (在我看来,模式就像是是一种思想,在这种思想的指引下,对代码和结构的一番加工和整合而已!都是套路!) 装饰模式又称包装(Wrapper)模式,是以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案.对客户端透明意味着接口不变. 2.问题: 在OO设计和开发过程中, 经常会遇到下面的情况: 我们需要为已经设计好的类添加新的职责, 通常情况下我们会定义一个新类继承自定义好的类. 由于组合比继承更好(复杂度高,继承深度深等原因, 类图: 3.如何实现装饰: (1):继承形式:(不推

设计模式--装饰模式

装饰模式用例图 class Program { static void Main(string[] args) { ConcreteComponent c = new ConcreteComponent(); ConcreteDecoratorA d1 = new ConcreteDecoratorA(); ConcreteDecoratorB d2 = new ConcreteDecoratorB(); d1.SetComponent(c); d2.SetComponent(d1); d2.O