Java设计模式之--装饰模式Decorator Pattern

首先，当我们遇到什么样的问题时，我们要用Decorator解决呢？

  例如，生活中身边最常见的水杯，不仅有不同大小，而且有不同颜色等，我们按继承的做法：
图画的难看了，大家将就一下，咱也不是美工出身 O(∩_∩)O~

abstract class Cup{
    abstract void volume();
}


interface Color{
	void color();
}

//实体类Code
class Cup300ml extends Cup {
    public void volume(){
    	System.out.print("300ml cup");
    }
}
class Cup500ml extends Cup{
	public void volume(){
		System.out.print("500ml cup");
	}
}
class Cup700ml extends Cup{
	public void volume(){
		System.out.print("700ml cup");
	}
}

//各种颜色的添加
class Cup300mlRed extends Cup300ml implements Color{

	@Override
	public void color() {
		System.out.print("red color");
	}
	
}
class Cup500mlRed extends Cup300ml implements Color{
	
	@Override
	public void color() {
		System.out.print("red color");
	}
}
class Cup700mlRed extends Cup300ml implements Color{
	
	@Override
	public void color() {
		System.out.print("red color");
	}
}
class Cup300mlYellow extends Cup300ml implements Color{
	
	@Override
	public void color() {
		System.out.print("yellow color");
	}
}

不难发现，子类会成级数增长。

Question：问题的所在就是：
  我们“过度地使用了继承来扩展对象的功能”，由于继承为类型引入的静态物质，使得这种扩展方式缺乏灵活性;并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能组合）会导致更多子类的膨胀。

Solution：采用装饰模式：
  动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。
                                      ------《设计模式》GOF

  装饰模式的 结构图：




具体代码实现：

abstract class Cup{
    abstract void volume();
}

//模式结构图中的Component
interface Color{
	void color();
}

//模式结构图中的ConcreteComponent
class Red implements Color{

	@Override
	public void color() {
		System.out.print("red color");
	}
	
}
class Yellow implements Color{
	
	@Override
	public void color() {
		System.out.print("yellow color");
	}
	
}

//模式结构图中的Decorator
class Cup300ml extends Cup {
    
   //在类里面，添加组合接口类Color，作为私有成员
    private Color mColor;

    public void volume(){
    	System.out.print("300ml cup ");
         mColor.color();
    }
    //在构造器中，将组合成员以参数形式传入
    public Cup300ml(Color c){
    	mColor = c;
    }
}
class Cup500ml extends Cup{
    private Color mColor;
    public void volume(){
    	System.out.print("500ml cup ");
         mColor.color();
    }
    public Cup500ml(Color c){
    	mColor = c;
    }
}
class Cup700ml extends Cup{
    private Color mColor;
    public void volume(){
    	System.out.print("700ml cup ");
         mColor.color();
    }
    public Cup700ml(Color c){
    	mColor = c;
    }
}

Test：测试：
 

public class Test{

    public static void main(String a[]){
	Red red = new Red();
	Yellow yellow = new Yellow();
	Cup300ml cup300 = new Cup300ml(red);
	Cup500ml cup500 = new Cup500ml(yellow);
	cup300.volume();
	cup500.volume();
    }
}

总结：
Decorator Pattern就如生活中的壁画一般：
 
适用性：
    需要扩展一个类的功能，或给一个类增加附加责任。
    需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
    需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。
  通过采用组合、而非继承的手法，Decorator模式实现了在运行时动态地扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了单独使用继承带来的“灵活性差"和"多子类衍生问题"。