【Java设计模式】八、装饰者模式

以你之姓@ 2024-04-23 15:52 0阅读 0赞

#### 文章目录 ####

*  0、背景
 *  1、装饰者模式
 *  2、案例
 *  3、使用场景
 *  4、源码中的实际应用

## 0、背景 ##

有个快餐店，里面的快餐有炒饭FriedRice 和 炒面FriedNoodles，且加配菜后总价不一样，计算麻烦。如果单独使用继承，那就是：

![在这里插入图片描述][cb1f7271de194e3ba7eb2f0afb5256af.png]

类爆炸不说，再来个炒河粉，就发现这样写扩展性很差。

## 1、装饰者模式 ##

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

*  抽象构件：具体构件的规范接口
 *  具体构件：被装饰（被增加功能）的原始对象
 *  抽象装饰：继承抽象构件
 *  具体装饰：实现抽象装饰，给具体构件对象添加功能

总之，用于动态扩展一个类的功能（增强目标对象），而非使用继承

## 2、案例 ##

![在这里插入图片描述][90722f1a7dd14fdd8bfbd2422bd3c76d.png]

定义快餐类（抽象构件）：

//快餐接口
    @Getter
    @Setter
    @AllArgsConstructor
    @NoArgsConstructor
    public abstract class FastFood {
        
        private float price;
        private String desc;
    
        public abstract float cost();  //获取价格
    }

定义炒饭、炒面类（具体的构件）

//炒饭
    public class FriedRice extends FastFood {
        
    
        public FriedRice() {
        
            super(10, "炒饭");    //调用父类的构造方法，给炒饭的价格和描述赋值，即一碗炒饭10元
        }
    
        public float cost() {
        
            return getPrice();
        }
    }

//炒面
    public class FriedNoodles extends FastFood {
        
    
        public FriedNoodles() {
        
            super(12, "炒面");   //调用父类的构造方法，给炒面的价格和描述赋值
        }
    
        public float cost() {
        
            return getPrice();
        }
    }

定义装饰类，属于**抽象装饰角色，实现或者继承抽象构件，并聚合它**

//配料
    public abstract class Garnish extends FastFood {
        
    
        private FastFood fastFood;   //声明抽象构件的变量
    
        public FastFood getFastFood() {
        
            return fastFood;
        }
    
        public void setFastFood(FastFood fastFood) {
        
            this.fastFood = fastFood;
        }
    
        public Garnish(FastFood fastFood, float price, String desc) {
        
            super(price,desc);
            this.fastFood = fastFood;
        }
    }

定义配料类（属于具体的装饰者角色），继承装饰者类：

//鸡蛋配料
    public class Egg extends Garnish {
        
    
        public Egg(FastFood fastFood) {
             //给属性赋值
            super(fastFood,1,"鸡蛋");    //一个鸡蛋一块钱 + 一份快餐
        }
    
        @Override
        public float cost() {
        
            return getPrice() + getFastFood().getPrice();   //鸡蛋的价格 + 快餐的价格
        }
    
        @Override
        public String getDesc() {
        
            return super.getDesc() + getFastFood().getDesc();
        }
    }

//培根配料
    public class Bacon extends Garnish {
        
    
        public Bacon(FastFood fastFood) {
        
    
            super(fastFood,2,"培根");   //一个培根两块钱 + 一份快餐
        }
    
        @Override
        public float cost() {
        
            return getPrice() + getFastFood().getPrice();
        }
    
        @Override
        public String getDesc() {
        
            return super.getDesc() + getFastFood().getDesc();
        }
    }

测试：

//测试类
    public class Client {
        
        public static void main(String[] args) {
        
            //点一份炒饭
            FastFood food = new FriedRice();
            //花费的价格
            System.out.println(food.getDesc() + " " + food.cost() + "元");
    
            System.out.println("========");
            //点一份加鸡蛋的炒饭
            FastFood food1 = new FriedRice();
    
            food1 = new Egg(food1);   妙！
            //花费的价格
            System.out.println(food1.getDesc() + " " + food1.cost() + "元");
    
            System.out.println("========");
            //点一份加培根的炒面
            FastFood food2 = new FriedNoodles();
            food2 = new Bacon(food2); 妙！
            //花费的价格
            System.out.println(food2.getDesc() + " " + food2.cost() + "元");
        }
    }

后续如果需求变动，要加一个新配料：火腿，那就定义一个类去继承Garnish类即可。且任何配料可以自由搭配任何主食（组合不同的装饰者对象），这比排列组合写出n个子类好多了。继承是静态的附加责任，装饰者则是动态的附加责任。

## 3、使用场景 ##

不能采用继承的方式对已有功能进行扩充时，可用装饰者模式。比如：

*  类被final修饰，不能被继承
 *  扩展项目太多，用继承会子类爆炸
 *  某些功能需要支持动态添加和动态撤销

## 4、源码中的实际应用 ##

JDK中BufferedWriter等包装类，用到了装饰者模式，对Writer类进行了增强

public class Demo {
        
        public static void main(String[] args) throws Exception{
        
            //创建BufferedWriter对象
            //创建FileWriter对象
            FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
            BufferedWriter bw = new BufferedWriter(fw);
    
            //写数据
            bw.write("hello Buffered");
    
            bw.close();
        }
    }

![在这里插入图片描述][86466a937ee24149a0120cac0d31ac5c.png]

[cb1f7271de194e3ba7eb2f0afb5256af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8fb986cfc5a9476889ddc5b7223935d4.png
[90722f1a7dd14fdd8bfbd2422bd3c76d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/cc05fd5e4dee44c681bff1c241fcd96a.png
[86466a937ee24149a0120cac0d31ac5c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/9f203883521546f686e4244398bf26bf.png