装饰器模式

1. 掌握装饰者模式的特征和应用场景。
2. 理解装饰者模式和适配器模式的根本区别。
3. 观察者模式在源码中的应用和实现原理
4. 了解装饰者模式和观察者模式的优点、缺点。

内容定位

1. 有重构项目需求的人群一定要掌握装饰者模式。
2. 有Swing 开发经验的人群更容易理解观察者模式

装饰者模式：是指在不改变原有对象的基础之上，将功能附件到对象上，提供了逼继承更有弹性的替代方案（扩展原有对象的功能）。
属于结构型模式

煎饼侠 水果蛋糕
对原有的属性包装，扩展

适用场景

1. 用于扩展一个类的功能或给一个类添加附加职责。
2. 动态的给一个对象添加功能，这些功能可以再动态的撤销

v1版本

   package com.decorator.v1;

   public class Battercake {
    
    protected String getMsg() {
        return "煎饼";
    }
    
    protected int price() {
        return 5;
    }
}

	package com.decorator.v1;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class BattercakeWithEgg extends  Battercake{
    @Override
    protected String getMsg() {
        return super.getMsg() + "+ 1个鸡蛋";
    }

    // 加一个鸡蛋加一块钱
    @Override
    protected int price() {
        return super.price() + 1;
    }
}

package com.decorator.v1;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class BattercakeWithEggAndSausage extends  BattercakeWithEgg{
    @Override
    protected String getMsg() {
        return super.getMsg() + "+ 1根香肠";
    }

    // 加一个香肠加2块钱
    @Override
    protected int price() {
        return super.price() + 2;
    }
}

package com.decorator.v1;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class BattercakeTest {

    
    
    public static void main(String[] args) {
    		// 基本套餐
            Battercake battercake = new Battercake();
            System.out.println(battercake.getMsg() + " 总价格:"  + battercake.price());
        	// 基本+1个鸡蛋
            Battercake  battercakeWithEgg = new BattercakeWithEgg();
            System.out.println(battercakeWithEgg.getMsg() + " 总价格:"  + battercakeWithEgg.price());
            // 基本+ 1个鸡蛋 + 1跟香肠
            Battercake battercakeWithEggAndSausage = new BattercakeWithEggAndSausage();
            System.out.println(battercakeWithEggAndSausage.getMsg() + " 总价格:"  + battercakeWithEggAndSausage.price());
        
            // 很饿 ，基本+1个鸡蛋 + 1根香肠，不能满足
            // 问题：在加跟香肠还得新建类， 层层继承
    }
    
}

v2版本

package com.decorator.v2;


public abstract class AbstractBattercake {
   
    protected  abstract  String getMsg();
    
    public abstract int getPrice();
}

package com.decorator.v2;

/**
 * 包装器
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public abstract class AbstractBattercakeDecorator extends AbstractBattercake {
    
    private  AbstractBattercake mAbstractBattercake;
    
    
    public AbstractBattercakeDecorator (AbstractBattercake abstractBattercake) {
         this.mAbstractBattercake = abstractBattercake;
    }
    
    
    @Override
    protected String getMsg() {
        return mAbstractBattercake.getMsg();
    }

    @Override
    public int getPrice() {
        return mAbstractBattercake.getPrice();
    }
}

package com.decorator.v2;

/**
 * 基础套餐
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class BaseBattercake extends AbstractBattercake{

    protected String getMsg() {
        return "煎饼";
    }

    public int getPrice() {
        return 5;
    }
}

package com.decorator.v2;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class EggDecorator extends  AbstractBattercakeDecorator {

    public EggDecorator(AbstractBattercake abstractBattercake) {
        super(abstractBattercake);
    }


    @Override
    protected String getMsg() {
        return super.getMsg() + "+1个鸡蛋";
    }

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

package com.decorator.v2;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class SausageDecorator extends  AbstractBattercakeDecorator {

    public SausageDecorator(AbstractBattercake abstractBattercake) {
        super(abstractBattercake);
    }


    @Override
    protected String getMsg() {
        return super.getMsg() + "+1根香肠";
    }

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

package com.decorator.v2;

/**
 * @author
 * @version 1.0
 * @date 2020/3/26
 */
public class BatterCakeTest {

    public static void main(String[] args) {
        AbstractBattercake abstractBattercake;
        // 路边摊买一个煎饼
        abstractBattercake= new BaseBattercake();
        
        // 加鸡蛋
        abstractBattercake = new EggDecorator(abstractBattercake);
        
        // 加香肠
        abstractBattercake = new SausageDecorator(abstractBattercake);
        
        // 很饿，再加香肠
        abstractBattercake = new SausageDecorator(abstractBattercake);
		// 需要加白菜，就建个白菜的包装器
		// 有了相应的包装器，需要什么，就包装什么
        System.out.println(abstractBattercake.getMsg() + "价格： " + abstractBattercake.getPrice());
    }
}

装饰者模式的优点：

1. 装饰者是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用
2. 通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同的效果。
3. 装饰者完全遵守开闭原则

缺点：

1. 会出现更多的代码，更多的类，增加程序复杂性
2. 动态装饰时，多层装饰时会更复杂