装饰者模式-结构型

最新推荐文章于 2024-10-13 10:58:03 发布

凉夏初晨

最新推荐文章于 2024-10-13 10:58:03 发布

阅读量151

点赞数 1

分类专栏：设计模式文章标签：装饰器模式

本文链接：https://blog.csdn.net/zhangxl123liang/article/details/124444934

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.基本概念

定义

在不改变原有对象的基础之上，将功能附加到对象上
提供了比继承更有弹性的替代方案（扩展原有对象功能）

使用场景

扩展一个类的功能或给一个类添加附加职责；
动态的给一个对象添加功能，这些功能可以再动态的撤销；

优点

（1）继承的有力补充，比继承灵活，不改变原有对象的情况下给一个对象扩展功能；
（2）通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果；
（3）符合开闭原则。

缺点

（1）会出现更多的代码，更多的类，增加程序复杂性；
（2）动态装饰时，多层装饰时会更复杂。
装饰者-相关设计模式：装饰者模式和代理模式；装饰者模式和适配器模式；
源码使用：IO流 Servlet Cache

2.代码示例

场景设计：煎饼果子-- 加鸡蛋+加火腿、加多个鸡蛋或火腿

第一版

package com.demo.design_pattern.structural.decorator.v1;

/**
 * Battercake
 * 场景  煎饼果子  加鸡蛋+加火腿  加多个鸡蛋或火腿
 *
 * @Description
 */
public class Battercake {

    public String getDesc() {
        return "煎饼";
    }

    public int cost() {
        return 8;
    }

}

package com.demo.design_pattern.structural.decorator.v1;

/**
 * BattercakeWithEgg
 *
 * @Description 加鸡蛋的煎饼
 */
public class BattercakeWithEgg extends Battercake {

    @Override
    public String getDesc() {
        return super.getDesc() + " 加一个鸡蛋";
    }

    @Override
    public int cost() {
        return super.cost() + 1;
    }

}

package com.demo.design_pattern.structural.decorator.v1;

/**
 * BattercakeWithEggSausage
 *
 * @Description 加鸡蛋火腿煎饼
 */
public class BattercakeWithEggSausage extends BattercakeWithEgg {

    @Override
    public String getDesc() {
        return super.getDesc() + " 加一个火腿";
    }

    @Override
    public int cost() {
        return super.cost() + 2;
    }
}

测试类

package com.demo.design_pattern.structural.decorator.v1;

/**
 * Test
 *
 * @Description
 */
public class Test {
    public static void main(String[] args) {
        Battercake battercake = new Battercake();
        System.out.println(battercake.getDesc() + " 销售价格：" + battercake.cost());

        Battercake battercakeWithEgg = new BattercakeWithEgg();
        System.out.println(battercakeWithEgg.getDesc() + " 销售价格：" + battercakeWithEgg.cost());

        Battercake battercakeWithEggSausage = new BattercakeWithEggSausage();
        System.out.println(battercakeWithEggSausage.getDesc() + " 销售价格：" + battercakeWithEggSausage.cost());
    }
}

测试结果

第二版

package com.demo.design_pattern.structural.decorator.v2;

/**
 * ABattercake
 *
 * @Description
 */
public abstract class ABattercake {
    protected String getDesc() {
        return "煎饼";
    }

    protected int cost() {
        return 8;
    }

}

package com.demo.design_pattern.structural.decorator.v2;

/**
 * Battercake
 *
 * @Description
 */
public class Battercake extends ABattercake {
    @Override
    protected String getDesc() {
        return "煎饼";
    }

    @Override
    protected int cost() {
        return 8;
    }
}

定义装饰器

package com.demo.design_pattern.structural.decorator.v2;

/**
 * AbstractDecorator
 *
 * @Description
 */
public class AbstractDecorator extends ABattercake {
    private ABattercake aBattercake;

    public AbstractDecorator(ABattercake aBattercake) {
        this.aBattercake = aBattercake;
    }

    @Override
    protected String getDesc() {
        return aBattercake.getDesc();
    }

    @Override
    protected int cost() {
        return aBattercake.cost();
    }

}

package com.demo.design_pattern.structural.decorator.v2;

/**
 * EggDecorator
 *
 * @Description 加蛋装饰器
 */
public class EggDecorator extends AbstractDecorator {


    public EggDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc() + " 加一个鸡蛋";
    }

    @Override
    protected int cost() {
        return super.cost() + 1;
    }
}

package com.demo.design_pattern.structural.decorator.v2;

/**
 * SausageDecorator
 *
 * @Description 加肠装饰器
 */
public class SausageDecorator extends AbstractDecorator {


    public SausageDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc() + " 加一根香肠";
    }

    @Override
    protected int cost() {
        return super.cost() + 2;
    }

}

测试类

package com.demo.design_pattern.structural.decorator.v2;

/**
 * Test
 *
 * @Description
 */
public class Test {
    public static void main(String[] args) {
        ABattercake aBattercake;
        aBattercake = new Battercake();//一个煎饼
        aBattercake = new EggDecorator(aBattercake);//加一个鸡蛋
        aBattercake = new EggDecorator(aBattercake);//加一个鸡蛋
        aBattercake = new SausageDecorator(aBattercake);//加一个肠
        System.out.println(aBattercake.getDesc() + "  销售价格：" + aBattercake.cost());
    }
}

测试结果

第三版

场景：装修工人的装修过程：清理墙面、刮腻子、涂油漆、贴壁画

package com.demo.design_pattern.structural.decorator.v3;
/**
 * 装饰器模式的优点：1、不改动原有代码，动态增加功能；2、对象之间不会相互依赖，松耦合，够优雅；3、符合开闭原则，扩展性好、便于维护；
 * 装饰器模式的缺点：1、装饰环节如果很多的话，会造成装饰器类膨胀；2、装饰器层层嵌套比较复杂，使用者必须清楚所有的装饰器类及其用途；
 */


/**
 * WallBeautify
 * 墙面装修接口
 * @Description
 */
public interface WallBeautify {
    /**
     * 装修操作
     */
    void operation();
}

package com.demo.design_pattern.structural.decorator.v3;

/**
 * WallBeautifyDecorator
 * 墙面装修装饰器角色
 *
 * @Description
 */
public abstract class WallBeautifyDecorator implements WallBeautify {

    /**
     * 持有一个Component对象实例
     */
    private WallBeautify wallBeautify;

    public WallBeautifyDecorator(WallBeautify wallBeautify) {
        this.wallBeautify = wallBeautify;
    }

    @Override
    public void operation() {
        wallBeautify.operation();
        decoration();
    }

    /**
     * 装饰器实现类自定义实现方法
     */
    public abstract void decoration();
}

package com.demo.design_pattern.structural.decorator.v3;

/**
 * WallBeautifyClean
 * 墙面装修基本实现
 *
 * @Description
 */
public class WallBeautifyClean implements WallBeautify {


    @Override
    public void operation() {
        System.out.println("开始清理墙面");
    }
}

package com.demo.design_pattern.structural.decorator.v3;

/**
 * WallBeautifyPutty
 * 墙面装修装饰器角色实现（刮腻子）
 * @Description
 */
public class WallBeautifyPutty extends WallBeautifyDecorator {

    public WallBeautifyPutty(WallBeautify wallBeautify) {
        super(wallBeautify);
    }

    @Override
    public void decoration() {
        System.out.println("开始刮腻子");
    }
}

package com.demo.design_pattern.structural.decorator.v3;

/**
 * WallBeautifyPaint
 * 墙面装修装饰器角色实现（涂油漆）
 *
 * @Description
 */
public class WallBeautifyPaint extends WallBeautifyDecorator {
    public WallBeautifyPaint(WallBeautify wallBeautify) {
        super(wallBeautify);
    }

    @Override
    public void decoration() {
        System.out.println("开始涂油漆");
    }
}

package com.demo.design_pattern.structural.decorator.v3;

/**
 * WallBeautifyHang
 * 墙面装修装饰器角色实现（挂壁画）
 *
 * @Description
 */
public class WallBeautifyHang extends WallBeautifyDecorator {

    public WallBeautifyHang(WallBeautify wallBeautify) {
        super(wallBeautify);
    }

    @Override
    public void decoration() {
        System.out.println("开始挂壁画");
    }
}

测试类

package com.demo.design_pattern.structural.decorator.v3;

/**
 * DecoratorTest
 *
 * @Description
 */
public class DecoratorTest {

    public static void main(String[] args) {
        //清理墙面
        WallBeautify wallBeautifyClean = new WallBeautifyClean();
        wallBeautifyClean.operation();
        System.out.println("---------------------------");
        //刮腻子
        WallBeautify wallBeautifyPutty = new WallBeautifyPutty(wallBeautifyClean);
        wallBeautifyPutty.operation();
        System.out.println("-----------------------------");
        //涂油漆
        WallBeautify wallBeautifyPaint = new WallBeautifyPaint(wallBeautifyPutty);
        wallBeautifyPaint.operation();
        System.out.println("----------------------------");
        //挂壁画
        WallBeautify wallBeautifyHang = new WallBeautifyHang(wallBeautifyPaint);
        wallBeautifyHang.operation();
        System.out.println("-----------------------------");
        //多层嵌套
        WallBeautify wbh = new WallBeautifyHang(new WallBeautifyPaint(new WallBeautifyPutty(new WallBeautifyClean())));
        wbh.operation();
        System.out.println("-----------------------------");

    }
}

测试结果