jeofey的专栏

一直努力奔跑的程序媛

设计模式(八)装饰模式

概念

装饰模式能够在不改变原类文件和继承的情况下,动态的宽展一个对象的功能,通过创建一个包装对象来包裹真实的对象。

模式结构

在这几类角色结构中,必须扩展Component的功能,但Component并不知道Docorator的存在,ConcreteDocorator才是具体的装饰对象,起了给Component添加职责的作用。

  • 抽象构建角色(Component):抽象接口,用来规范准备接口附加责任的对象;
  • 具体构建角色(ConcreteComponent):定义一个将要接口附加责任的类;
  • 装饰角色(Docorator):定义一个与抽象构建角色一致的接口,持有一个抽象构建角色的引用;
  • 具体的装饰角色(ConcreteDocorator):负责给构建角色添加附加责任。

示例说明

/**
 * 抽象构建角色
 */
public interface Icomponent {
    void showCoffee();
    double showPrice();
}

/**
 * 具体的构建角色
 */
class Coffee implements Icomponent{
    private String name;
    private double price;

    public Coffee(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public void showCoffee() {
        System.out.println(this.name+"咖啡");
    }

    @Override
    public double showPrice() {
        return this.price;
    }
    // 省略get,set方法
}

/**
 * 装饰角色
 */
abstract class Docorator implements Icomponent{
    private Icomponent component;

    public void setComponent(Icomponent component) {
        this.component = component;
    }

    @Override
    public void showCoffee() {
        component.showCoffee();
    }

    @Override
    public double showPrice() {
        return component.showPrice();
    }
}

/**
 * 具体的装饰角色1
 */
class Milk extends Docorator{
    @Override
    public void showCoffee() {
        System.out.print("加奶的");
        super.showCoffee();
    }

    @Override
    public double showPrice() {
        return 20.0 + super.showPrice();
    }
}

/**
 * 具体的装饰角色2
 */
class Sugar extends Docorator{
    @Override
    public void showCoffee() {
        System.out.print("加糖的");
        super.showCoffee();
    }

    @Override
    public double showPrice() {
        return 10.0 + super.showPrice();
    }
}

class DocoratorClient{
    public static void main(String[] args){
        Icomponent coffee = new Coffee("蓝山", 80.0);
        Docorator milk = new Milk();
        Docorator sugar = new Sugar();

        coffee.showCoffee();
        System.out.println(coffee.showPrice());
        System.out.println("======================================");

        milk.setComponent(coffee);
        milk.showCoffee();
        System.out.println(milk.showPrice());
        System.out.println("======================================");

        sugar.setComponent(milk);
        sugar.showCoffee();
        System.out.println(sugar.showPrice());
    }
}
运行结果:

蓝山咖啡
80.0
======================================
加奶的蓝山咖啡
100.0
======================================
加糖的加奶的蓝山咖啡
110.0

装饰模式的思考起点就是利用“多用组合,少用继承”的原则;Java中装饰模式典型的使用是I/0流;装饰模式和AOP在思想上有共同之处。

装饰模式优缺点

  • 比继承更灵活:继承是静态的,一旦继承,多有子类都有同样的功能;而装饰则是把功能分散到每个装饰器中,然后通过对象组合的方式,动态的组合调用;
  • 更容易复用功能:功能分散到每个装饰器中,每个装饰器的功能相对简单,有利于复用;
  • 简化高层定义:通过组合个方式给对象增加更多的功能,不需要在定义顶层类的时候把所有的功能都定义出来;
  • 会产生很多细粒度对象:由于功能细分到每个装饰器,这样装饰器类会越来越多。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/jeofey/article/details/46789197
个人分类: 设计模式
所属专栏: 设计模式
上一篇Spring MVC 3.0.5+Spring 3.0.5+MyBatis3.0.4全注解实例详解(五)
下一篇Spring2.5学习4.1_静态代理实现
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭