设计模式之装饰者模式

一.装饰者模式特点：
1.装饰者和被装饰者对象有相同的超类
2.可以用一个或多个装饰者包装一个对象
3.由于装饰者和被装饰者具有相同超类，所以任何需要被包装对象的场合，可以用装饰过的对象代替
4.装饰者可以再所委托被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的（重点）
5.对象可以在任何时候被装饰，所以可以在运行时动态的不限量的用你喜欢的装饰者来装饰对象
二.装饰者模式定义：

动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更具有弹性的替代方案

三.代码部分

1.咖啡超类

package com.pattern.decorate;
/*
 * 咖啡超类
 */
public abstract class Coffee {
    
    String des;//对咖啡的描述

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }
    
    public abstract double cost();//不同的咖啡花费不同
    
}

2.咖啡实体类一意大利咖啡，被修饰者

package com.pattern.decorate;
/**
 * 意大利咖啡，被装饰者
 * @author Administrator
 *
 */
public class ItalianCoffee extends Coffee {

    public ItalianCoffee() {
        des = "意大利咖啡";
    }
    
    @Override
    public double cost() {
        return 10.99;

    }

}

3.咖啡实体类2被装饰者

package com.pattern.decorate;
/**
 * 美式咖啡，被装饰者
 * @author Administrator
 *
 */
public class CafeAmericano extends Coffee {

    public CafeAmericano() {
        des = "美式咖啡";
    }
    
    @Override
    public double cost() {
        // TODO Auto-generated method stub
        return 8.10;
    }

}

4.装饰者超类，调料

package com.pattern.decorate;
/**
 * 装饰者的超类，咖啡调料，也是咖啡一部分，所以继承Coffee
 * @author Administrator
 *
 */
public abstract class CoffeeCondiment extends Coffee {

    
    
    @Override
    public abstract String getDes();//要知道调料加到什么咖啡中
    @Override
    public abstract double cost();//不同的调料价格不一样
}

5.装饰者实现类1巧克力

package com.pattern.decorate;
/**
 * 装饰者实现类，用来修饰Coffee对象
 * @author Administrator
 *
 */
public class Chocolate extends CoffeeCondiment {

    Coffee coffee;//肯定会有这个引用表示调料要加到咖啡中

    public Chocolate(Coffee coffee) {
        this.coffee = coffee;
        this.des = "巧克力";
    }

    @Override
    public String getDes() {
        // TODO Auto-generated method stub
        return this.des+coffee.getDes();
    }

    @Override
    public double cost() {
        // TODO Auto-generated method stub
        return coffee.cost()+5.1;//加一种调料价钱加一点
    }

}

6.装饰者实现类2冰块

package com.pattern.decorate;
/**
 * 装饰者实现类，用来修饰Coffee对象，
 * @author Administrator
 *
 */
public class Ice extends CoffeeCondiment {

    Coffee coffee;//肯定会有这个引用表示调料要加到咖啡中

    public Ice(Coffee coffee) {
        this.coffee = coffee;
        this.des = "冰块";
    }

    @Override
    public String getDes() {
        // TODO Auto-generated method stub
        return this.des+coffee.getDes();
    }

    @Override
    public double cost() {
        // TODO Auto-generated method stub
        return coffee.cost()+1.5;//加一种调料价钱加一点
    }

}

7.装饰者实现类3摩卡

package com.pattern.decorate;
/**
 * 装饰者实现类，用来修饰Coffee对象，
 * @author Administrator
 *
 */
public class Mocha extends CoffeeCondiment {

    Coffee coffee;//肯定会有这个引用表示调料要加到咖啡中

    public Mocha(Coffee coffee) {
        this.coffee = coffee;
        this.des = "摩卡";
    }

    @Override
    public String getDes() {
        // TODO Auto-generated method stub
        return this.des+coffee.getDes();
    }

    @Override
    public double cost() {
        // TODO Auto-generated method stub
        return coffee.cost()+8.2;//加一种调料价钱加一点
    }

}

8.测试类

package com.pattern.decorate;
/**
 * 装饰者模式测试代码
 * @author Administrator
 *
 */
public class Client {

    public static void main(String[] args) {
        //创建原始对象,意大利咖啡
        Coffee coffee1 = new ItalianCoffee();
        System.out.println("给我来一杯"+coffee1.getDes()+",价格："+coffee1.cost());
        System.out.println("---------------------------------------------");
        Coffee coffee2 = new CafeAmericano();
        System.out.println("给我来一杯"+coffee2.getDes()+",价格："+coffee2.cost());
        System.out.println("---------------------------------------------");
        //创建装饰者
        Coffee co = new  Chocolate(coffee1);//加入巧克力
        co = new Ice(co);//在加入冰块
        co = new Mocha(co);//再加入摩卡
        System.out.println("给我来一杯"+co.getDes()+",价格："+co.cost());
        System.out.println("------------------------------------------------");
        Coffee cof = new Ice(coffee2);
        cof = new Mocha(cof);
        System.out.println("给我来一杯"+cof.getDes()+",价格："+cof.cost());
        
        
        
    }

}

9.运行结果

10.装饰者模式要点：

@1继承属于扩展形式之一，但不是达到弹性设计的最佳方案

@2在我们的设计中，应该允许行为可以被扩展，而无需修改现有的代码

@3组合和委托可用于在运行时动态添加新的行为

@4除了继承装饰者模式也可以让我们扩展行为

@5装饰者模式意味着一群装饰者类，这些类用来包装具体的组件

@6装饰这类反映出被装饰者的组件类型，事实上他们都具有相同的类型，都经过接口或者继承实现

@7装饰者可以在被装饰者的行为前面与后面加上自己的行为，甚至被装饰者的整个行为替换掉而达到特定目的

@8可以用许许多多装饰者包装一个组件

@9装饰者一般对组件的客户是透明的，除非客户程序依赖于组建的具体类型

@10装饰者会导致设计中出现许许多多的小对象，如果过度使用，会让程序变得很复杂