23种设计模式之四（装饰者模式）

装饰者模式：（动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性）

 其别名为包装器（Wrapper）；装饰模式是一种对象结构模式。

设计原则：对扩展开放、对修改关闭，这句话体现在我如果想扩展被装饰者类的行为，无须修改装饰者抽象类；只需继承装饰者抽象类，实现额外的一些装饰或者叫行为即可对被装饰者进行包装。

所以：扩展体现在继承、修改体现在子类中，而不是具体的抽象类，这充分体现了依赖倒置原则。

举例：

咖啡馆订单项目：
1）、咖啡种类：Espresso、ShortBlack、LongBlack、Decaf
2）、调料：Milk、Soy、Chocolate
3）、扩展性好、改动方便、维护方便

就如同调制一杯饮品：

　　主体：黑咖啡、浓缩黑咖啡、无咖啡因咖啡、意式浓缩咖啡

　　包装：牛奶、巧克力、豆浆

 超类（被装饰者）：

package com.java.jikexueyuan.coffeebar;

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

 主体（被装饰者）：

package com.java.jikexueyuan.coffeebar.coffee;

import com.java.jikexueyuan.coffeebar.Drink;

//中间层：将各种咖啡共有的功能进行封装
public  class Coffee extends Drink {
    @Override
    public float cost() {
        // TODO Auto-generated method stub
        return super.getPrice();
    }
}

package com.java.jikexueyuan.coffeebar.coffee;

public class ShortBlack extends Coffee{
    
    public ShortBlack(){
        super.setDescription("ShortBlack");
        super.setPrice(5.0f);
    }

}

package com.java.jikexueyuan.coffeebar.coffee;

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

}

package com.java.jikexueyuan.coffeebar.coffee;

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

package com.java.jikexueyuan.coffeebar.coffee;

public class Espresso extends Coffee{
    
    public Espresso(){
        super.setDescription("Espresso");
        super.setPrice(4.0f);
    }

}

装饰者：

package com.java.jikexueyuan.coffeebar.decorator;

import com.java.jikexueyuan.coffeebar.Drink;

//中间层：将各种调料的共有功能封装出来
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();
    }
    
    }

包装（装饰）：

package com.java.jikexueyuan.coffeebar.decorator;

import com.java.jikexueyuan.coffeebar.Drink;

public class Chocolate extends Decorator {

    public Chocolate(Drink Obj) {        
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Chocolate");
        super.setPrice(3.0f);
    }

}

package com.java.jikexueyuan.coffeebar.decorator;

import com.java.jikexueyuan.coffeebar.Drink;

public class Milk extends Decorator {

    public Milk(Drink Obj) {        
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Milk");
        super.setPrice(2.0f);
    }

}

package com.java.jikexueyuan.coffeebar.decorator;

import com.java.jikexueyuan.coffeebar.Drink;

public class Soy extends Decorator {

    public Soy(Drink Obj) {        
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Soy");
        super.setPrice(1.5f);
    }

}

测试：

package com.java.jikexueyuan.coffeebar;

import com.java.jikexueyuan.coffeebar.coffee.Decaf;
import com.java.jikexueyuan.coffeebar.coffee.LongBlack;
import com.java.jikexueyuan.coffeebar.decorator.Chocolate;
import com.java.jikexueyuan.coffeebar.decorator.Milk;

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

Java内置装饰者：

2、编写自己的Java I/O装饰者：

package com.java.jikexueyuan.myiodecorator;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

public class UpperCaseInputStream extends FilterInputStream{

    protected UpperCaseInputStream(InputStream in) {
        super(in);
        // TODO Auto-generated constructor stub
    }

    public int read() throws IOException
    {
        int c=super.read();
        return c==-1?c:Character.toUpperCase((char)(c));
    }
    public int read(byte[] b,int offset,int len) throws IOException
    {
        int result=super.read(b,offset,len);
        for(int i=0;i<result;i++)
        {
            b[i]=(byte)Character.toUpperCase((char)(b[i]));
        }
        
        return result;
    }
}

package com.java.jikexueyuan.myiodecorator;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class InputTest {
    public static void main(String[] args) {
        int c;
        try {
            InputStream in = new UpperCaseInputStream(new BufferedInputStream(
                    new FileInputStream("D:\test\test.txt")));
            while((c=in.read())>=0)
            {
                System.out.print((char)c);
                
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

ZHE SHI CE SHI WEN JIAN !

注意：
一个装饰者类的接口必须与被装饰者的接口一致；
尽量保持具体装饰者类作为一个“轻”类，也就是说不要把太多的逻辑和状态放到具体装饰者类去实现；
优先使用组合、聚合原则，少用继承。

（参考：http://www.cnblogs.com/chenxing818/p/4705919.html或http://blog.csdn.net/jason0539/article/details/22713711）

优点：
装饰模式与类继承的目的都是扩展对象的功能，但是装饰模式可以提供比类继承更多的灵活性；
通过使用不同的具体装饰类以及这些装饰类的排列组合，开发者可以创造出很多不同行为的组合；
缺点：
这种比类继承更加灵活机动的特性，也同时意味着装饰模式比类继承更容易出错；
使用装饰模式增加了代码的复杂度。

应用场景：

1、在不影响其它对象情况下，以动态透明的方式给单个对象添加职责；

2、需要动态给一个对象添加功能，这些功能可以在动态的被撤销；

3、当不能采用类继承的方式进行扩展时。

　　一种情况是可能有大量独立的扩展，每一种组合将产生大量的子类，使得子类数量呈爆炸性增长；

　　另一种情况可以是因为类定义不能继承（final）或不能用于生成子类。