Java设计模式之装饰者模式

Java设计模式之装饰者模式

先考虑这样一个生活场景，煎饼摊前面有三个人饿了要买煎饼，第一个只要煎饼，第二个煎饼加鸡蛋，第三个煎饼加鸡蛋加香肠。下面看代码实现。

//新建一个类 煎饼
public class Battercake {
    public String getDesc(){
        return "煎饼";
    }
    public int price(){
        return 5;
    }

}


//新建类 煎饼 加鸡蛋
public class BattercakeWithEgg extends Battercake {

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

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


//新建类  煎饼 加鸡蛋 加香肠
public class BattercakeWithEggSausage extends BattercakeWithEgg {
    @Override
    public String getDesc() {
        return super.getDesc() +" 加一根香肠";
    }

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

//调用
 public static void main(String [] a){
        Battercake battercake=new Battercake();
        System.out.println(battercake.getDesc()+";价格："+battercake.price());

        Battercake battercake2=new BattercakeWithEgg();
        System.out.println(battercake2.getDesc()+";价格："+battercake2.price());

        Battercake battercake3=new BattercakeWithEggSausage();
        System.out.println(battercake3.getDesc()+";价格："+battercake3.price());
    }

//结果
煎饼;价格：5
煎饼 加一个鸡蛋;价格：6
煎饼 加一个鸡蛋 加一根香肠;价格：8

看一下UML的类图：

现在如果来了第四个人想买煎饼加2个蛋一根香肠或者煎饼加1个蛋两根香肠呢？再考虑其他的组合呢？此时代码的扩展性很差，很容易导致类爆炸。

下面看看装饰者模式怎么优雅的应对这种局面。

抽象的实体类，确定的实体类，抽象的装饰者，确定的装饰者。被装饰者是煎饼，装饰者是鸡蛋和香肠。

//抽象的煎饼
public abstract class ABattercake {
    public abstract String getDesc();
    public abstract int price();
}

//实体的煎饼
public class Battercake extends ABattercake{
    @Override
    public String getDesc() {
        return "煎饼";
    }

    @Override
    public int price() {
        return 5;
    }
}

//抽象的装饰者继承抽象的煎饼
public class ADecorator extends ABattercake{
    private ABattercake aBattercake;

    //把要被装饰的抽象类作为构造的入参
    public ADecorator(ABattercake aBattercake) {
        this.aBattercake = aBattercake;
    }

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

    @Override
    public int price() {
        return this.aBattercake.price();
    }
}

//鸡蛋 实体装饰者
public class EggDecorator extends ADecorator{
    public EggDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

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

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

//香肠 实体装饰者
public class SuasageDecorator extends ADecorator{
    public SuasageDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

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

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

//调用
public static void main(String [] a){
        ABattercake aBattercake;
        aBattercake=new Battercake();
        aBattercake=new EggDecorator(aBattercake);
        aBattercake=new EggDecorator(aBattercake);
        aBattercake=new SuasageDecorator(aBattercake);
        System.out.println(aBattercake.getDesc()+"; 价格："+aBattercake.price());

    }

//结果
煎饼 加一个鸡蛋 加一个鸡蛋 加一根香肠; 价格：9

看看此时UML的类图：