设计模式(二) 装饰模式

 

装饰模式

装饰模式又叫包装模式。装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的类图

 

　在装饰模式中的角色有：

　　●　　抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。

　　●　　具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。

　　●　　装饰(Decorator)角色：持有一个构件(Component)对象的实例,

　　　　  并定义一个与抽象构件接口一致的接口。

　　●　　具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。

源代码实现

抽象构件(Component)角色

public interface Component {

    /**抽象接口方法*/
    void service();

}

具体构件(ConcreteComponent)角色

public class ConcreteComponent implements Component{

    public ConcreteComponent() {
    }

    @Override
    public void service() {
        System.out.println("我要接收附加责任");
    }
}

装饰(Decorator)角色

public abstract class Decorator implements Component {

    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void service() {
        component.service();
    }
}

具体装饰(ConcreteDecoratorA)角色

public class DecoratorA extends Decorator {

    public DecoratorA(Component component) {
        super(component);
    }

    @Override
    public void service() {
        super.service();
        System.out.println("我是装饰者A");
    }
}

具体装饰(ConcreteDecoratorB)角色

public class DecoratorB extends Decorator {

    public DecoratorB(Component component) {
        super(component);
    }

    @Override
    public void service() {
        super.service();
        System.out.println("我是装饰者B");
    }
}

真实案例

程序员这个行业，难免会遇到晚上加班的情况。如果加班太晚回不去就需要打车。我们以打车这件事情去理解装饰模式。
我们知道出租车是小汽车的一种。打车可以分为几件事情去执行：叫车、等待、坐车、付费结束。

打车的类图

　在装饰模式中的角色有

　　●　　抽象构件(Taxi)角色：给出一个抽象接口driving()，每个出租车都能开。

　　●　　具体构件(Car)角色：每个小汽车开之前都有一些准备工作，点火、踩离合、挂挡、松手刹...

　　●　　装饰(Work)角色：持有一个构件(Taxi)对象的实例，

　　　　  并定义一个与抽象构件接口一致的driving()接口。并附加一个work()接口。

　　●　　具体装饰(CallTaxi、Wait、ByBus、PayMoney)角色：实现具体的附加责任。

源代码实现

抽象构件(Taxi)角色

public interface Taxi {

    /**给出一个抽象接口driving()，每个出租车都能开*/
    void driving();

}

具体构件(Car)角色

public class Car implements Taxi {

    public Car() {
    }

    @Override
    public void driving() {
        //每个小汽车开之前都有一些准备工作，点火、踩离合、挂挡、松手刹...
        System.out.println("第一步准备工作：点火、踩离合、挂挡、松手刹...");
    }
}

装饰(Work)角色

public abstract class Work implements Taxi{

    private Taxi taxi;

    public Work(Taxi taxi) {
        this.taxi = taxi;
    }

    @Override
    public void driving() {
        taxi.driving();
    }
}

具体装饰(CallTaxi)角色

public class CallTaxi extends Work {

    public CallTaxi(Taxi taxi) {
        super(taxi);
    }

    @Override
    public void driving() {
        super.driving();
        System.out.println("第二步：我要叫车了...");
    }
}

具体装饰(Wait)角色

public class Wait extends Work {

    public Wait(Taxi taxi) {
        super(taxi);
    }

    @Override
    public void driving() {
        super.driving();
        System.out.println("第三步：正在等待中...");
    }
}

具体装饰(ByBus)角色

public class ByBus extends Work {

    public ByBus(Taxi taxi) {
        super(taxi);
    }

    @Override
    public void driving() {
        super.driving();
        System.out.println("第四步：坐上车了...");
    }
}

具体装饰(PayMoney)角色

public class PayMoney extends Work {

    public PayMoney(Taxi taxi) {
        super(taxi);
    }

    @Override
    public void driving() {
        super.driving();
        System.out.println("第五步：到家付钱了...");
    }
}

工厂(TaxiFactory)

public class TaxiFactory {

    /**出租车工厂控制出租车工作顺序*/
    public static Taxi geTaxi(){
        //执行顺序 Car.driving() -> CallTaxi.driving()-> Wait.driving()-> 
　　　　　 //ByBus.driving()-> PayMoney.driving()
        return new PayMoney(new ByBus(new Wait(new CallTaxi(new Car()))));
    }

}

测试类(TestMain)

public class TestMain {


    public static void main(String[] args) {
        Taxi taxi = TaxiFactory.geTaxi();
        taxi.driving();
    }

}

测试类执行结果

第一步准备工作：点火、踩离合、挂挡、松手刹...
第二步：我要叫车了...
第三步：正在等待中...
第四步：坐上车了...
第五步：到家付钱了...