Java学习笔记——设计模式之三.装饰模式

函数应该做一件事，做好这件事，只做这一件事。

　　　　　　　　　　　　　　　　　　　　——Clean Code

 

装饰模式,上代码:

先定义零件类:

package cn.no3.decorator.template;

public abstract class Component {

    public abstract void operation();
}

再定义具体零件类(即被装饰类)继承零件类:

package cn.no3.decorator.template;

public class ConcreteComponent extends Component{

    @Override
    public void operation() {
        // TODO Auto-generated method stub
        System.out.println("对一个Object进行装饰：");
    }

}

然后定义装饰类,继承零件类:

package cn.no3.decorator.template;

public class Decorator extends Component {

    protected Component component;
    
    public void setComponent(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        //调用的是传入component的operation方法
        if (component != null) {
            component.operation();
        }

    }

}

定义装饰类的子类:

package cn.no3.decorator.template;

public class ConcreteDecoratorA extends Decorator {

    private String addedField;
    
    @Override
    public void operation() {
        // TODO Auto-generated method stub
        super.operation();//第一行调用super,则从前往后包装.反之则从后往前包装
        addedField = "新的装饰物A";
        System.out.println("装饰了:"+addedField);
    }
}

public class ConcreteDecoratorB extends Decorator {
    
    @Override
    public void operation() {
        // TODO Auto-generated method stub
        super.operation();
        AddedBehavior();
    }

    private void AddedBehavior() {
        // TODO Auto-generated method stub
        System.out.println("完成装饰，最后照个相");
    }
    
}

测试类测试:

package cn.no3.decorator.template;

public class _Test {

    public static void main(String[] args) {
        //新建装饰对象
        ConcreteComponent concreteComponent = new ConcreteComponent();
        ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA();
        ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB();
        //逐层包装
        //如果注掉下句,还是先调用A的super,发现没传component,于是A的super什么都不做
        concreteDecoratorA.setComponent(concreteComponent);//A先调用cC,cC方法不再调用super.
        concreteDecoratorB.setComponent(concreteDecoratorA);//B先调用A
        //输出最终结果
        concreteDecoratorB.operation();
    }
}

把这个例子中的Component类换成接口也是一样的:

举个例子:

需求:

定义一个角色,让他实现IWearable接口,

再定义装备实现IWearable接口

人物装备装备.

上代码:

package cn.no3.decorator.instance;

public abstract interface IWearable {

    public abstract void operation();
}

package cn.no3.decorator.instance;

public class Clothes implements IWearable {

    protected IWearable component;
    
    public void setComponent(IWearable component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }

    }

}

package cn.no3.decorator.instance;

//即使只有一双鞋也要定义父类,否则无法通过对象的super.operation对装饰进行传递
public class Shoes implements IWearable {

    protected IWearable component;
    
    public void setComponent(IWearable component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }
    }

}

package cn.no3.decorator.instance;

public class Weapons implements IWearable {

    protected IWearable component;
    
    public void setComponent(IWearable component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }

    }

}

他们的子类都是重写父类operation()方法,最先调用(或者最后调用),super.operation();此处省略若干行

package cn.no3.decorator.instance;

public class WeaponA extends Weapons {

    @Override
    public void operation() {
        // TODO Auto-generated method stub
        super.operation();
        System.out.println("装备了:霜之哀伤");
    }
}

角色类

package cn.no3.decorator.instance;

public class Character implements IWearable{

    @Override
    public void operation() {
        // TODO Auto-generated method stub
        System.out.println("对一个人物进行装备：");
    }

}

测试类:

package cn.no3.decorator.instance;

public class _Test {

    public static void main(String[] args) {
        //新建装备对象
        Character concreteComponent = new Character();
        ClotheA fantasyKiller = new ClotheA();
        ClotheB bravingArmor = new ClotheB();
        WeaponA frostmourne = new WeaponA();
        WeaponB DoubleRoses = new WeaponB();
        ShoesA shoes = new ShoesA();
        //逐层包装
        fantasyKiller.setComponent(concreteComponent);
        bravingArmor.setComponent(fantasyKiller);
        frostmourne.setComponent(bravingArmor);
        DoubleRoses.setComponent(frostmourne);
        shoes.setComponent(DoubleRoses);//shoes.setComponent(shoes)会陷入死循环
        //输出最终结果
        shoes.operation();
    }
}

装饰模式是为已有功能动态地添加更多功能的一种方式

装饰模式把每个要装饰的功能放在单独的类中，并让这个类包装它所需要装饰的对象。因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了。

装饰功能的核心是：把类中的装饰功能从类中搬出去。