1、星巴克咖啡订单项目（咖啡馆)

1)咖啡种类/单品咖啡:Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)

2)调料:Milk、Soy(豆浆)、Chocolatc

3)要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便

4)使用OO的来计算不同种类咖啡的费用:客户可以点单品咖啡，也可以单品咖啡+调料组合。

2、方案1-解决星巴克咖啡订单项目

3、方案1-解决星巴克咖啡订单问题分析

1)Drink是一个抽象类，表示饮料

2)des就是对咖啡的描述,比如咖啡的名字

3) cost()方法就是计算费用，Drink类中做成一个抽象方法.

4)Decaf就是单品咖啡，继承 Drink,并实现cost

5) Espress && Milk就是单品咖啡+调料，这个组合很多

6)问题:这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现
类爆炸

4、方案2-解决星巴克咖啡订单(好点)

1)前面分析到方案1因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到Drink类，这样就不会造成类数量过多。从而提高项目的维护性(如图)

2)说明: milk,soy,chocolate可以设计为Boolean,表示是否要添加相应的调料.

5、方案2-解决星巴克咖啡订单问题分析

1)方案2可以控制类的数量，不至于造成很多的类

2)在增加或者删除调料种类时，代码的维护量很大

3)考虑到用户可以添加多份调料时，可以将hasMilk返回一个对应int

4)考虑使用装饰者模式

6、装饰者模式定义

1)装饰者模式:动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者棋式也体现了
开闭原则(ocp)

2)这里提到的动态的将新功能附加到对象和ocp 原则，在后面的应用实例上会以代码的形式体现，请同学们注意
体会。

7、装饰者模式原理

1)装饰者模式就像打包一个快递

主体:比如:陶瓷、衣服(Component)//被装饰者

包装:比如:报纸填充、塑料泡沫、纸板、木板(Decorator)

2) Component主体:比如类似前面的Drink

3) ConcreteComponent 和 Decorator

ConcreteComponent:具体的主体，

比如前面的各个单品咖啡

4) Decorator:装饰者，比如各调料。

在如图的Component 与ConcreteComponent之间，如果ConcreteComponent类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象层一个类。

8、装饰者模式解决星巴克咖啡订单

9、装饰者模式下的订单:2份巧克力+一份牛奶的LongBlack

说明
1)Mik包含了LongBlack
2)一份Chocolate包含了(Milk+LongBlack)
3)一份Chocolate包含了(Chocolate+Milk+LongBlack)
4)这样不管是什么形式的单品咖啡+调料组合，通过递归方式可以方便的组合和维护。

10、装饰者模式咖啡订单项目应用实例

代码演示

Chocolate：

//具体的Decorator， 这里就是调味品
public class Chocolate extends Decorator {

	public Chocolate(Drink obj) {
		super(obj);
		setDes(" 巧克力 ");
		setPrice(3.0f); // 调味品 的价格
	}

}

Coffee：

public class Coffee  extends Drink {

	@Override
	public float cost() {
		// TODO Auto-generated method stub
		return super.getPrice();
	}

	
}

CoffeeBar：

public class CoffeeBar {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack

		// 1. 点一份 LongBlack
		Drink order = new LongBlack();
		System.out.println("费用1=" + order.cost());
		System.out.println("描述=" + order.getDes());

		// 2. order 加入一份牛奶
		order = new Milk(order);

		System.out.println("order 加入一份牛奶 费用 =" + order.cost());
		System.out.println("order 加入一份牛奶 描述 = " + order.getDes());

		// 3. order 加入一份巧克力

		order = new Chocolate(order);

		System.out.println("order 加入一份牛奶 加入一份巧克力  费用 =" + order.cost());
		System.out.println("order 加入一份牛奶 加入一份巧克力 描述 = " + order.getDes());

		// 3. order 加入一份巧克力

		order = new Chocolate(order);

		System.out.println("order 加入一份牛奶 加入2份巧克力   费用 =" + order.cost());
		System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());
	
		System.out.println("===========================");
		
		Drink order2 = new DeCaf();
		
		System.out.println("order2 无因咖啡  费用 =" + order2.cost());
		System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
		
		order2 = new Milk(order2);
		
		System.out.println("order2 无因咖啡 加入一份牛奶  费用 =" + order2.cost());
		System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());

	
	}

}

DeCaf：

public class DeCaf extends Coffee {

	public DeCaf() {
		setDes(" 无因咖啡 ");
		setPrice(1.0f);
	}
}

Decorator：

public class Decorator extends Drink {
	private Drink obj;
	
	public Decorator(Drink obj) { //组合
		// TODO Auto-generated constructor stub
		this.obj = obj;
	}
	
	@Override
	public float cost() {
		// TODO Auto-generated method stub
		// getPrice 自己价格
		return super.getPrice() + obj.cost();
	}
	
	@Override
	public String getDes() {
		// TODO Auto-generated method stub
		// obj.getDes() 输出被装饰者的信息
		return des + " " + getPrice() + " && " + obj.getDes();
	}
	
	

}

Drink：

public abstract class Drink {

	public String des; // 描述
	private float price = 0.0f;
	public String getDes() {
		return des;
	}
	public void setDes(String des) {
		this.des = des;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	
	//计算费用的抽象方法
	//子类来实现
	public abstract float cost();
	
}

Espresso：

public class Espresso extends Coffee {
	
	public Espresso() {
		setDes(" 意大利咖啡 ");
		setPrice(6.0f);
	}
}

LongBlack：

public class LongBlack extends Coffee {

	public LongBlack() {
		setDes(" longblack ");
		setPrice(5.0f);
	}
}

Milk：

public class Milk extends Decorator {

	public Milk(Drink obj) {
		super(obj);
		// TODO Auto-generated constructor stub
		setDes(" 牛奶 ");
		setPrice(2.0f); 
	}

}

ShortBlack：

public class ShortBlack extends Coffee{
	
	public ShortBlack() {
		setDes(" shortblack ");
		setPrice(4.0f);
	}
}

Soy：

public class Soy extends Decorator{

	public Soy(Drink obj) {
		super(obj);
		// TODO Auto-generated constructor stub
		setDes(" 豆浆  ");
		setPrice(1.5f);
	}

}

11、装饰者模式在JDK应用的源码分析

Java的IO结构，FilterInputStream就是一个装饰者

源码说明：

2022-06-29

start:

12、装饰器模式总结：

装饰模式：动态地给一个对象增加一些额外的职责。就扩展功能而言，装饰提供了一种比子类更加灵活的替代方案

装饰器类的结构

Component(抽象构件)：它是具体构件和抽象装饰器类的共同父类，声明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明性。

ConcreteComponent(具体构件)：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中的声明方法，装饰器类可以给它增加额外的职责（方法）

Decorator(抽象装饰器类):它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责通常在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。

ConcreteDecorator(具体装饰类)：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在抽象装饰类中定义的方法，并可以增加新的方法，以扩展对象的行为

总结：装饰模式是一种用于替代继承的技术，它通过一种无须定义子类的方式给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。

end