[Java] Java设计模式之java装饰者模式详解

• Component（抽象构件）：给出一个抽象接口，以规范准备接收附加责任的对象。
• ConcreteComponent（具体构件）：定义一个将要接收附加责任的类。
• Decorator（抽象装饰类）：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口。
• ConcreteDecorator（具体装饰类）：负责给构件对象“贴上”附加的责任。
  

public interface Component {
  public void sampleOperation();
}

public class ConcreteComponent implements Component {
  @Override
  public void sampleOperation() {
    // 写相关的业务代码
  }
}

public class Decorator implements Component{
  private Component component;
  public Decorator(Component component){
    this.component = component;
  }
  @Override
  public void sampleOperation() {
    // 委派给构件
    component.sampleOperation();
  }
}

public class ConcreteDecoratorA extends Decorator {
  public ConcreteDecoratorA(Component component) {
    super(component);
  }
  @Override
  public void sampleOperation() {
super.sampleOperation();
    // 写相关的业务代码
  }
}

public class ConcreteDecoratorB extends Decorator {
  public ConcreteDecoratorB(Component component) {
    super(component);
  }
  @Override
  public void sampleOperation() {
  super.sampleOperation();
    // 写相关的业务代码
  }
}

public abstract class Drink
{
   protected String decription="";//描述
   public String getDecription() {
    return decription;
   }
   public abstract Integer cost();//返回饮料的价格
}

//缓冲层----所有种类咖啡的共同点抽取出来
public abstract class Coffee extends Drink
{
  //共同特点：计算价格
  @Override
  public Integer cost() {
    //价格从0累加
    return 0;
  }
}

public class LongBlack extends Coffee
{
  LongBlack()
  {
    decription="美式咖啡";
  }
  @Override
  public Integer cost() {
    return 15;
  }
}

public class ChinaBlack extends Coffee
{
  ChinaBlack()
  {
    decription="中式咖啡";
  }
  @Override
  public Integer cost() {
    return 10;
  }
}

public class Espresso extends Coffee
{
  //设置描述信息
  Espresso()
  {
    decription="意大利咖啡";
  }
  @Override
  public Integer cost() {
    //意大利咖啡20元
    return 20;
  }
}

//装饰者
public abstract class Decorator extends Drink
{
  @Override
  public abstract String getDecription();
}

public class Milk extends Decorator{
  Drink drink;
  Milk(Drink drink)
  {
    this.drink=drink;
  }
  @Override
  public String getDecription()
  {
    return "加了牛奶的"+this.drink.getDecription();
  }
  @Override
  public Integer cost()
  {
    return this.drink.cost()+3;
  }
}

public class Chocolate extends Decorator{
   //用一个实例变量记录饮料，也就是被装饰者
  Drink drink;
  Chocolate(Drink drink) {
     this.drink=drink;
  }
  @Override
  public String getDecription() {
    return "加了巧克力的"+drink.getDecription();
  }
  @Override
  public Integer cost() {
    //在原有饮料价格的基础上加上调料味的价格
    return 5+drink.cost();
  }
}

public class test
{
  @Test
  public void test()
  {
    //模拟下单
    //首先点一个美式咖啡，不加任何调料
    Drink drink=new LongBlack();
    System.out.println("购买了"+drink.getDecription()+"  花了"+drink.cost());
    //给美式咖啡加一个巧克力
    drink=new Chocolate(drink);
    System.out.println("购买了"+drink.getDecription()+"  花了"+drink.cost());
    //给美式咖啡再加一个牛奶
    drink=new Milk(drink);
    System.out.println("购买了"+drink.getDecription()+"  花了"+drink.cost());
    //再把牛奶和巧克力加一次
    drink=new Chocolate(drink);
    System.out.println("购买了"+drink.getDecription()+"  花了"+drink.cost());
    drink=new Milk(drink);
    System.out.println("购买了"+drink.getDecription()+"  花了"+drink.cost());
    System.out.println("====================================================");
    //简化写法
    Drink d=new Chocolate(new Milk(new ChinaBlack()));
    System.out.println("购买了"+d.getDecription()+"  花了"+d.cost());
  }
}

Drink drink=new LongBlack();
//给美式咖啡加一个巧克力
drink=new Chocolate(drink);

Drink drink=new LongBlack();
//给美式咖啡加一个巧克力
Chocolate drink=new Chocolate(drink);

Drink drink=new LongBlack();
//给美式咖啡加一个巧克力
Chocolate drink=new Chocolate(drink);
//售卖巧克力棒
drink.sell();

• 对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。
• 可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的具体装饰类，从而实现不同的行为。
• 可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。
• 具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合 “开闭原则”。
  

• 使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，大量小对象的产生势必会占用更多的系统资源，在一定程序上影响程序的性能。
• 装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。
  

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
• 当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种扩展或者扩展之间的组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类已定义为不能被继承（如Java语言中的final类）
  

public class IOTest {
  public static void main(String[] args) throws IOException {
    // 流式读取文件
    DataInputStream dis = null;
    try{
      dis = new DataInputStream(
          new BufferedInputStream(
              new FileInputStream("test.txt")
          )
      );
      //读取文件内容
      byte[] bs = new byte[dis.available()];
      dis.read(bs);
      String content = new String(bs);
      System.out.println(content);
    }finally{
      dis.close();
    }
  }
}