Java设计模式之装饰者模式

最新推荐文章于 2025-12-05 17:02:52 发布

原创最新推荐文章于 2025-12-05 17:02:52 发布 · 137 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #开发语言

本文详细介绍了装饰者模式，包括其定义、角色划分（抽象构件、具体构件和装饰者），并通过FastFood类和Garnish类的示例展示如何动态添加功能。装饰者模式强调灵活性、可扩展性和松耦合，与静态代理进行比较，突出了其目的和构建方式的不同。

定义

指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

结构

装饰模式中的角色：

抽象构件角色：定义一个抽象接口以规范准备接收附加责任的对象。
具体构件角色：实现抽象构件，通过装饰角色为其添加一些职责。
抽象装饰角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

案例

抽象构建角色

public abstract class FastFood {
    private BigDecimal price; //  价格
    private String desc; //描述

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public FastFood(BigDecimal price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    //计算总价
    public abstract BigDecimal cost();
}

具体构建角色

//食物1
public class Food1 extends FastFood {

    public Food1() {
        super(BigDecimal.valueOf(10),"炒饭");
    }


    @Override
    public BigDecimal cost() {
        return getPrice();
    }
}
//食物2
public class Food2 extends FastFood {
    public Food2() {
        super(BigDecimal.valueOf(12), "炒面");
    }

    @Override
    public BigDecimal cost() {
        return getPrice();
    }
}

抽象装饰类

public abstract class Garnish extends FastFood{
    private FastFood fastFood;

    public Garnish(BigDecimal price, String desc, FastFood fastFood) {
        super(price, desc);
        this.fastFood = fastFood;
    }

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }
}

具体装饰类

public class Garnish1 extends Garnish {
    public Garnish1(FastFood fastFood) {
        super(BigDecimal.valueOf(1), "配料1", fastFood);
    }

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }

    @Override
    public BigDecimal cost() {
        //getFastFood().getPrice与getFastFood().cost() 区别很大欸
        return getPrice().add(getFastFood().cost());
    }
}

public class Garnish2 extends Garnish {
    public Garnish2(FastFood fastFood) {
        super(BigDecimal.valueOf(2), "配料2", fastFood);
    }

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }

    @Override
    public BigDecimal cost() {
        return getPrice().add(getFastFood().cost());
    }
}

测试

public class Client {
    public static void main(String[] args) {
        FastFood fastFood = new Food1();
        System.out.println(fastFood.getDesc()+":"+fastFood.cost());

        System.out.println("==================");
        fastFood=new Garnish1(fastFood);
        System.out.println(fastFood.getDesc()+":"+fastFood.cost());
        System.out.println("==================");
        fastFood=new Garnish2(fastFood);
        System.out.println(fastFood.getDesc()+":"+fastFood.cost());
    }
}

运行结果为：

炒饭:10

==================

配料1炒饭:11

==================

配料2配料1炒饭:13

有点像递归的意思，不断地嵌套通过cost方法取得自己与上一级的售价和，直到达到最底层Food1或Food2后开始return

好处

饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。