设计模式之装饰者模式

装饰者模式

现在有这样一个项目，星巴克咖啡订单项目：

1. 咖啡种类/单品咖啡：Espresso（意大利浓咖啡）、ShortBlack、LongBlack（美式咖啡）、Decaf（无因咖啡）
2. 调料：Milk、Soy（豆浆）、Chocolate
3. 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
4. 使用OO的来计算不同种类咖啡的费用：客户可以点单品咖啡，也可以单品咖啡+调料组合

方案一（较差）：

方案一问题分析：

1. Drink 是一个抽象类，表示饮料
2. des就是对咖啡的描述，比如咖啡的名字
3. cost()方法就是计算费用，Drink类中做成一个抽象方法
4. Decaf 就是单品咖啡，继承Drink，并实现cost
5. Espress && Milk 就是单品咖啡+调料， 这个组合很多
6. 问题：这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现类爆炸

方案二：

方案二问题分析：

1. 方案2可以控制类的数量，不至于造成很多的类
2. 在增加或者删除调料种类时，代码的维护量很大
3. 考虑到用户可以添加多份调料时，可以将hasMilk 返回一个对应int
4. 考虑使用装饰者模式

 

装饰者模式定义

装饰者模式：指在不改变现有对象结构的情况下，动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则（ocp）。

装饰者（Decorator）模式的主要优点有：

1. 采用装饰模式扩展对象的功能比采用继承方式更加灵活
2. 可以设计出多个不同的具体装饰类，创造出多个不同行为的组合

其主要缺点是：装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。

 

装饰模式的结构与实现

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。下面来分析其基本结构和实现方法。

模式的结构：

1. 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象
2. 具体构件（Concrete    Component）角色：实现抽象构件，通过装饰角色为其添加一些职责
3. 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能
4. 具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任

模式的实现：

package decorator;

public class DecoratorPattern {

    public static void main(String[] args) {
        Component p = new ConcreteComponent();
        p.operation();
        System.out.println("---------------------------------");
        Component d = new ConcreteDecorator(p);
        d.operation();
    }
}


// 抽象构件角色
interface Component {
    public void operation();
}


// 具体构件角色
class ConcreteComponent implements Component {

    public ConcreteComponent() {
        System.out.println("创建具体构件角色");       
    }   

    public void operation() {
        System.out.println("调用具体构件角色的方法operation()");           
    }
}


// 抽象装饰角色
class Decorator implements Component {

    private Component component;
   
    public Decorator(Component component) {
        this.component = component;
    }   

    public void operation() {
        component.operation();
    }
}


// 具体装饰角色
class ConcreteDecorator extends Decorator {

    public ConcreteDecorator(Component component) {
        super(component);
    }   

    public void operation() {
        super.operation();
        addedFunction();
    }

    public void addedFunction() {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");           
    }
}

程序运行结果如下：

创建具体构件角色
调用具体构件角色的方法operation()
---------------------------------
调用具体构件角色的方法operation()
为具体构件角色增加额外的功能addedFunction()

 设计模式应用实例：

package com.atguigu.decorator;

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();
	
}


package com.atguigu.decorator;

public class Decorator extends Drink {

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

}


package com.atguigu.decorator;

public class Coffee extends Drink {

	@Override
	public float cost() {
		return super.getPrice();
	}

}


package com.atguigu.decorator;

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

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

}


package com.atguigu.decorator;

public class Milk extends Decorator {

	public Milk(Drink obj) {
		super(obj);
		setDes(" 牛奶 ");
		setPrice(2.0f); 
	}

}


package com.atguigu.decorator;

public class Soy extends Decorator{

	public Soy(Drink obj) {
		super(obj);
		setDes(" 豆浆 ");
		setPrice(1.5f);
	}

}


package com.atguigu.decorator;

public class DeCaf extends Coffee {

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


package com.atguigu.decorator;

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


package com.atguigu.decorator;

public class LongBlack extends Coffee {

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


package com.atguigu.decorator;

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


package com.atguigu.decorator;

public class CoffeeBar {

	public static void main(String[] args) {

		// 装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack
		// 1. 点一份 LongBlack
		Drink order = new LongBlack();
		System.out.println("费用 = " + 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());
	
	}

}

装饰模式的应用场景：

前面讲解了关于装饰模式的结构与特点，下面介绍其适用的应用场景，装饰模式通常在以下几种情况使用：

1. 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类
2. 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现
3. 当对象的功能要求可以动态地添加，也可以再动态地撤销时

装饰模式在Java语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。

代码示例：

package com.atguigu.jdk;

import java.io.DataInputStream; 
import java.io.FileInputStream; 
import java.io.InputStream;

public class Decorator {

    public static void main(String[] args) throws Exception {
        // 说明
        // 1. InputStream 是抽象类, 类似我们前面讲的 Drink
        // 2. FileInputStream 是 InputStream 子类，类似我们前面的 DeCaf, LongBlack
        // 3. FilterInputStream 是 InputStream 子类:类似我们前面 的 Decorator 修饰者
        // 4. DataInputStream 是 FilterInputStream 子类，具体的修饰者，类似前面的 Milk, Soy 等 
        // 5. FilterInputStream 类 有 protected volatile InputStream in; 即含被装饰者
        // 6. 分析得出在 jdk 的 io 体系中，就是使用装饰者模式
        DataInputStream dis = new DataInputStream(new FileInputStream("d:\\abc.txt")); 
        System.out.println(dis.read());
        dis.close();
    } 
}

 

装饰模式的扩展

装饰模式所包含的 4 个角色不是任何时候都要存在的，在有些应用环境下模式是可以简化的，如以下两种情况。

(1) 如果只有一个具体构件而没有抽象构件时，可以让抽象装饰继承具体构件，其结构图如图 4 所示。

(2) 如果只有一个具体装饰时，可以将抽象装饰和具体装饰合并，其结构图如图 5 所示。

 

部分引用：http://c.biancheng.net/view/1322.html