今天LZ带给大家的是装饰者模式，提起这个设计模式，LZ心里一阵激动，这是LZ学习JAVA以来接触的第一个设计模式，也许也是各位接触的第一个设计模式。记得当初老师在讲IO的时候就提到过它：“是你还有你，一切拜托你。”没错，这就是装饰者模式最简洁的定义了。下面LZ引出标准的定义（出自百度百科）：装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
ex:工厂制作上衣，白上衣是30，蓝上衣40，红上衣50，另外还有往衣服上绣的图案，花图案需10元，草图案需5元。现在工厂需要计算出成本价，要求设计出这个实现代码。
我们初看这题有什么思路，难道要设计出5个类吗？这显然不行，如果工厂老板突然让加一个新的图案，岂不是“类爆炸”！这个时候，我们可能想到了用另一种实现方式，把CLothes做为基类，然后设置whiteClothes，
blueClothes ，redClothes 为三个布尔类型变量，在基类里设置cost方法，然后图案设置为子类继承它，各自重写cost方法。这样就把原本的五个类缩小成了三个。
//白上衣是30，蓝上衣40，红上衣50，另外还有往衣服上绣的图案，花图案需10元，草图案需5元
public class Clothes {
private int cost;
private boolean whiteClothes = false;
private boolean blueClothes = false;
private boolean redClothes = false;
public int cost(){
if(whiteClothes){
cost += 30;
}
if(blueClothes){
cost += 40;
}
if(redClothes){
cost += 50;
}
return cost;
}
public int getCost() {
return cost;
}
public void setCost(int cost) {
this.cost = cost;
}
public boolean isWhiteClothes() {
return whiteClothes;
}
public void setWhiteClothes(boolean whiteClothes) {
this.whiteClothes = whiteClothes;
}
public boolean isBlueClothes() {
return blueClothes;
}
public void setBlueClothes(boolean blueClothes) {
this.blueClothes = blueClothes;
}
public boolean isRedClothes() {
return redClothes;
}
public void setRedClothes(boolean redClothes) {
this.redClothes = redClothes;
}
}
class FlowerPattern extends Clothes{
public int cost(){
return 10+super.cost();
}
}
class GrassPattern extends Clothes{
public int cost(){
return 5+super.cost();
}
}
测试方法
public class TestDemo1 {
public static void main(String[] args) {
FlowerPattern flowerPattern = new FlowerPattern();
flowerPattern.setBlueClothes(true);
System.out.println("蓝上衣花图案一共花费："+flowerPattern.cost());
GrassPattern grassPattern = new GrassPattern();
grassPattern.setRedClothes(true);
System.out.println("红上衣草图案一共花费："+grassPattern.cost());
}
}
这种写法，相信看过LZ前两篇文章的人一眼就看出了问题，我们虽然写出了实现，但是由于类之间过于耦合，导致不利于维护，当我们添加一个新的颜色的上衣时，需要更改Clothes代码，这就违反了我们的设计原则：类应该对扩展开发，对修改关闭，也就是我们常说的开闭原则。在这里，LZ带着大家一起认识装饰者模式，我们以上衣为主体，以图案来“装饰”上衣。比方说，如果商家要蓝上衣花草图案，那么，我们要做的是：
①拿一个蓝色上衣对象
②以花图案对象装饰它
③以草图案对象装饰它
④调用cost()方法，并依赖委托将调料的价钱加上去
下面我们画个图更加详细了解如何以装饰者构造衣服订单
①以BlueClothes对象开始，别忘了它继承自clothes，且有一个用来计算上衣价钱的cost()方法
②建立一个花图案对象，并用它将BlueClothes对象包(wrap)起来。FlowerPattern对象是一个装饰者，它的类型"反映"了它所装饰的对象(本例中，就是Clothes)。所谓的"反映"，指的是两者类型一致。所以FlowerPattern也有一个cost()方法。通过多态，也可以把FlowerPattern所包裹的任何clothes当成是clothes(因为FlowerPattern是clothes的子类)
③接下来还要建立草图案GrassPattern装饰者，并用它将FlowerPattern对象包起来。别忘了，BlueClothes继承自Clothes,且有一个cost()方法，用来计算衣服价钱
④这样，计算总价钱通过调用最外圈装饰者(GrassPattern)的cost()就可以办得到。GrassPatternd cost()方法会先委托它装饰的对象(也就是FlowerPattern)计算出价钱，然后再加上上衣的价钱。
现在，LZ来总结一下我们目前所指的的一切：
=。=装饰者和被装饰者对象有相同的基类。
=。=我们可以用一个或多个装饰者包装一个对象。
=。=既然装饰者和被装饰对象有相同的基类，所以在任何需要原始对象(被包装的)的场合，可以用装饰过的对象代替它。
=。=装饰者可以在所委托被装饰者的行为之前与/或之后，加上自己的行为，以达到特定的目的，
=。=对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象
接下来我们先来看看装饰者模式的说明:装饰者模式动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
下面我们来看下类图：
到这里，大家可能会有些混淆:这里使用的是继承不是组合？。其实，这么做的重点在于，装饰者和被装饰者必须是一样的类型，也就是有共同的基类，这是相当关键的地方。在这里我们利用继承达到“类型匹配”，而不是利用继承获得“行为”。那么这个行为又来自哪里？当我们将装饰者与组件组合时，就是再加入新的行为，所得到的新行为，并不是继承自超累，而是由组合对象得来的。
分支
这里，为了防止各位看不懂图的结构，我们先切出一个分支来描述一下这张图，当然如果各位已经看懂，也可以直接跳过这段分支，直接看下面LZ对一开始那个问题的分析。
1，Component接口可以是接口也可以是抽象类，甚至是一个普通的父类（这个强烈不推荐，普通的类作为继承体系的超级父类不易于维护）。
2，装饰器的抽象父类Decorator并不是必须的。
那么我们将上述标准的装饰器模式，用我们熟悉的JAVA代码给诠释一下。首先是待装饰的接口Component。
public interface Component {
void method();
}
接下来便是我们的一个具体的接口实现类，也就是俗称的原始对象，或者说待装饰对象。
public class ConcreteComponent implements Component{
public void method() {
System.out.println("原来的方法");
}
}
下面便是我们的抽象装饰器父类，它主要是为装饰器定义了我们需要装饰的目标是什么，并对Component进行了基础的装饰。
public abstract class Decorator implements Component{
protected Component component;
public Decorator(Component component) {
super();
this.component = component;
}
public void method() {
component.method();
}
}
再来便是我们具体的装饰器A和装饰器B。
public class ConcreteDecoratorA extends Decorator{
public ConcreteDecoratorA(Component component) {
super(component);
}
public void methodA(){
System.out.println("被装饰器A扩展的功能");
}
public void method(){
System.out.println("针对该方法加一层A包装");
super.method();
System.out.println("A包装结束");
}
}
public class ConcreteDecoratorB extends Decorator{
public ConcreteDecoratorB(Component component) {
super(component);
}
public void methodB(){
System.out.println("被装饰器B扩展的功能");
}
public void method(){
System.out.println("针对该方法加一层B包装");
super.method();
System.out.println("B包装结束");
}
}
下面给出我们的测试类。我们针对多种情况进行包装。
public class Main {
public static void main(String[] args) {
Component component =new ConcreteComponent();//原来的对象
System.out.println("------------------------------");
component.method();//原来的方法
ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA(component);//装饰成A
System.out.println("------------------------------");
concreteDecoratorA.method();//原来的方法
concreteDecoratorA.methodA();//装饰成A以后新增的方法
ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB(component);//装饰成B
System.out.println("------------------------------");
concreteDecoratorB.method();//原来的方法
concreteDecoratorB.methodB();//装饰成B以后新增的方法
concreteDecoratorB = new ConcreteDecoratorB(concreteDecoratorA);//装饰成A以后再装饰成B
System.out.println("------------------------------");
concreteDecoratorB.method();//原来的方法
concreteDecoratorB.methodB();//装饰成B以后新增的方法
}
}
从这个例子中，各位应该对装饰者模式的结构有了一定的了解，那么接下来我们解决之前的那个问题。
分支结束
接下来我们开始看最开始的问题代码：
先从clothes下手，这里我们加一个description 用来描述的更详细一下：
public abstract class Clothes {
String description = "unknown Clothes";
public String getDescription(){
return description;
}
public abstract double cost();
}
接下来是装饰者类，我们成为图案Pattern类，也继承自Clothes
abstract class Pattern extends Clothes{
public abstract String getDescription();
}
有了两个基类，我们为实现一些衣服，这里我们为了描述清楚，每个都写构造方法：
class WhiteClothes extends Clothes{
public WhiteClothes(){
description = "WhiteClothes";
}
@Override
public double cost() {
return 30;
}
}
class BlueClothes extends Clothes{
public BlueClothes(){
description = "BlueClothes";
}
@Override
public double cost() {
return 40;
}
}
class RedClothes extends Clothes{
public RedClothes(){
description = "RedClothes";
}
@Override
public double cost() {
return 50;
}
}
接下来我们开始写图案代码，也就是具体装饰者类，为了能够跟上思路，LZ标了注释
class FlowerPattern extends Pattern{//花图案是一个装饰者，让它扩展自Pattern，而Pattern又扩展自Clothes
//我们为了能让FlowerPattern能够引用clothes，用一个实例变量记录衣服，也就是被装饰者，然后在构造器中将其记录在实例变量里
private Clothes clothes;
public FlowerPattern(Clothes clothes){
this.clothes = clothes;
}
@Override
public String getDescription() {
return clothes.getDescription() + ",FlowerPattern";//这里我们把图案也描述出来
}
@Override
public double cost() {
return 10+clothes.cost();//我们把调用委托给被装饰对象，以计算价钱，然后再加上FlowerPattern的价钱，得到最终结果
}
}
同理，我们写出草图案的具体实现：
class GrassPattern extends Pattern{//草图案是一个装饰者，让它扩展自Pattern，而Pattern又扩展自Clothes
//我们为了能让FlowerPattern能够引用clothes，用一个实例变量记录衣服，也就是被装饰者，然后在构造器中将其记录在实例变量里
private Clothes clothes;
public GrassPattern(Clothes clothes){
this.clothes = clothes;
}
@Override
public String getDescription() {
return clothes.getDescription() + ",GrassPattern";//这里我们把图案也描述出来
}
@Override
public double cost() {
return 5+clothes.cost();//我们把调用委托给被装饰对象，以计算价钱，然后再加上GrassPattern的价钱，得到最终结果
}
}
最后，测试一下：
public class TestDemo2 {
public static void main(String[] args) {
Clothes clothes = new BlueClothes();
clothes = new FlowerPattern(clothes);
clothes = new GrassPattern(clothes);
System.out.println(clothes.getDescription()+"$"+clothes.cost());
}
}
看到这里，LZ相信大家一定有些熟悉，记得我们在学习IO的时候曾学过包装流，
其中FileInputStream是被装饰的“组件”。
BufferedInputStream是一个具体的“装饰者”，它加入两种行为：利用缓冲输入来改进性能利用一个readLine()方法（用来一次读取一行文本输入数据）来增强接口。
LineNumberInputStream也是一个具体的“装饰者”。它加上了计算行数的能力
这里也引出了装饰者模式的一个缺点，常常造成设计中有大量的小类，数量实在太多，可能会造成使用此API程序员的困扰。但是如果我们已经了解了装饰者的工作原理，以后当使用别人的大量装饰者的API时，就可以很容易辨别出他们的装饰者类是如何组织的，以方便用包装方式去的想要的行为。
装饰者模式就到此结束了，感谢大家的收看。
下期预告，单例模式。