《Head First 设计模式》:装饰者模式

正文

一、定义

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

要点:

  • 装饰者和被装饰者有相同的超类型。
  • 可以用一个或多个装饰者包装一个对象。
  • 既然装饰者和被装饰者有相同的超类型,所以在任何需要原始对象(被装饰者)的场合,都可以用装饰过的对象代替它。
  • 装饰者可以在被装饰者的行为之前与/或之后,加上自己的行为,甚至将被装饰者的行为整个取代掉,以到达特定的目的。
  • 对象可以在任何时候被装饰,所以可以在运行时动态地、不限量地用装饰者装饰对象。
  • 装饰者会导致设计中出现许多小对象,如果过度使用,会让程序变得很复杂。

二、实现步骤

1、创建组件接口

装饰者和被装饰者都必须实现组件接口。

也可以用组件抽象类,然后让装饰者和被装饰者继承组件抽象类,只要装饰者和被装饰者具有相同的超类型即可。

/**
 * 组件接口(装饰者和被装饰者都必须实现该接口)
 */
public interface Component {

    public void doSomething();
}

2、创建具体的组件,并实现组件接口

/**
 * 具体组件(被装饰者)
 */
public class ConcreteComponent implements Component {

    @Override
    public void doSomething() {
        System.out.println("ConcreteComponent do something...");
    }
}

3、创建装饰者抽象类,并实现组件接口

如果只有一个装饰者,也可以不创建装饰者抽象类,而是由具体的装饰者直接实现组件接口。

/**
 * 组件装饰者抽象类
 */
public abstract class ComponentDecorator implements Component {
    
    protected Component component;
    
    public ComponentDecorator(Component component) {
        // 通过构造传入组件(被装饰者)
        this.component = component;
    }

    @Override
    public void doSomething() {
        // 委托给组件(被装饰者)
        component.doSomething();
    }
}

4、创建具体的装饰者,并继承装饰者抽象类

(1)装饰者 A

/**
 * 装饰者A
 */
public class ComponentDecoratorA extends ComponentDecorator {

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

    @Override
    public void doSomething() {
        // 装饰者添加自己的业务代码
        
        component.doSomething();
        
        // 装饰者添加自己的业务代码
        System.out.println("ComponentDecoratorA do something...");
    }
}

(2)装饰者 B

/**
 * 装饰者B
 */
public class ComponentDecoratorB extends ComponentDecorator {

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

    @Override
    public void doSomething() {
        // 装饰者添加自己的业务代码
        
        component.doSomething();
        
        // 装饰者添加自己的业务代码
        System.out.println("ComponentDecoratorB do something...");
    }
}

5、使用装饰者装饰组件

public class Test {
    
    public static void main(String[] args) {
        // 具体组件(被装饰者)
        Component component = new ConcreteComponent();
        // 用装饰者A装饰组件
        ComponentDecorator componentDecoratorA = new ComponentDecoratorA(component);
        // 用装饰者B装饰组件
        ComponentDecorator componentDecoratorB = new ComponentDecoratorB(component);
        
        component.doSomething();
        componentDecoratorA.doSomething();
        componentDecoratorB.doSomething();
    }
}

三、举个栗子

1、背景

星巴兹是以扩张速度最快而闻名的咖啡连锁店。因为扩张速度实在太快了,他们准备更新订单系统,以合乎他们的饮料供应要求——

顾客在购买咖啡时,可以要求在其中加入各种调料,例如:蒸奶、豆浆、摩卡(巧克力风味)或覆盖奶泡。星巴兹会根据所加入的调料收取不同的费用。所以订单系统必须考虑到这些调料部分。

2、实现

把调料理解为饮料装饰者,然后以饮料为主体,用调料来“装饰”饮料。

(1)创建饮料抽象类

/**
 * 饮料抽象类(组件)
 */
public abstract class Beverage {

    protected String description = "Unknown Beverage";
    
    /**
     * 描述
     */
    public String getDescription() {
        return description;
    }
    
    /**
     * 价格
     */
    public abstract double cost();
}

(2)创建具体的饮料,并继承饮料抽象类

/**
 * 浓缩咖啡
 */
public class Espresso extends Beverage {
    
    public Espresso() {
        description = "Espresso";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}
/**
 * 综合咖啡
 */
public class HouseBlend extends Beverage {
    
    public HouseBlend() {
        description = "House Blend Coffee";
    }

    @Override
    public double cost() {
        return 0.89;
    }
}

(3)创建调料抽象类,并继承饮料抽象类

/**
 * 调料抽象类(装饰者抽象类)
 */
public abstract class CondimentDecorator extends Beverage {

    @Override
    public abstract String getDescription();
}

(4)创建具体的调料,并继承调料抽象类

/**
 * 摩卡(装饰者)
 */
public class Mocha extends CondimentDecorator {
    
    Beverage beverage;
    
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

    @Override
    public double cost() {
        // 加上摩卡的价格
        return beverage.cost() + 0.20;
    }
}
/**
 * 豆浆(装饰者)
 */
public class Soy extends CondimentDecorator {
    
    Beverage beverage;
    
    public Soy(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Soy";
    }

    @Override
    public double cost() {
        // 加上豆浆的价格
        return beverage.cost() + 0.15;
    }
}
/**
 * 奶泡(装饰者)
 */
public class Whip extends CondimentDecorator {
    
    Beverage beverage;
    
    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    @Override
    public double cost() {
        // 加上奶泡的价格
        return beverage.cost() + 0.10;
    }
}

(5)测试

public class Test {
    
    public static void main(String[] args) {
        // 浓缩咖啡
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + " $" + beverage.cost());
        
        // 综合咖啡 
        Beverage beverage2 = new HouseBlend();
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
        // 添加摩卡
        beverage2 = new Mocha(beverage2);
        // 添加豆浆
        beverage2 = new Soy(beverage2);
        // 添加奶泡
        beverage = new Whip(beverage2);
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
    }
}
posted @ 2020-07-13 22:10  惊却一目  阅读(55)  评论(0编辑  收藏