设计模式(二) 装饰模式

 

装饰模式

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

 

装饰模式的类图

 

 

　在装饰模式中的角色有：

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

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

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

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

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

 

源代码实现

 

抽象构件(Component)角色

1 public interface Component {
2 
3     /**抽象接口方法*/
4     void service();
5 
6 }

 

 

具体构件(ConcreteComponent)角色

 1 public class ConcreteComponent implements Component{
 2 
 3     public ConcreteComponent() {
 4     }
 5 
 6     @Override
 7     public void service() {
 8         System.out.println("我要接收附加责任");
 9     }
10 }

 

 

装饰(Decorator)角色

 1 public abstract class Decorator implements Component {
 2 
 3     private Component component;
 4 
 5     public Decorator(Component component) {
 6         this.component = component;
 7     }
 8 
 9     @Override
10     public void service() {
11         component.service();
12     }
13 }

 

 

具体装饰(ConcreteDecoratorA)角色

 1 public class DecoratorA extends Decorator {
 2 
 3     public DecoratorA(Component component) {
 4         super(component);
 5     }
 6 
 7     @Override
 8     public void service() {
 9         super.service();
10         System.out.println("我是装饰者A");
11     }
12 }

 

 

具体装饰(ConcreteDecoratorB)角色

 1 public class DecoratorB extends Decorator {
 2 
 3     public DecoratorB(Component component) {
 4         super(component);
 5     }
 6 
 7     @Override
 8     public void service() {
 9         super.service();
10         System.out.println("我是装饰者B");
11     }
12 }

 

真实案例

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

打车的类图

 

　在装饰模式中的角色有

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

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

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

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

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

 

源代码实现

 

抽象构件(Taxi)角色

1 public interface Taxi {
2 
3     /**给出一个抽象接口driving()，每个出租车都能开*/
4     void driving();
5 
6 }

 

 

 

 

具体构件(Car)角色

 1 public class Car implements Taxi {
 2 
 3     public Car() {
 4     }
 5 
 6     @Override
 7     public void driving() {
 8         //每个小汽车开之前都有一些准备工作，点火、踩离合、挂挡、松手刹...
 9         System.out.println("第一步准备工作：点火、踩离合、挂挡、松手刹...");
10     }
11 }

 

 

 

装饰(Work)角色

 1 public abstract class Work implements Taxi{
 2 
 3     private Taxi taxi;
 4 
 5     public Work(Taxi taxi) {
 6         this.taxi = taxi;
 7     }
 8 
 9     @Override
10     public void driving() {
11         taxi.driving();
12     }
13 }

 

 

 

 

具体装饰(CallTaxi)角色

 1 public class CallTaxi extends Work {
 2 
 3     public CallTaxi(Taxi taxi) {
 4         super(taxi);
 5     }
 6 
 7     @Override
 8     public void driving() {
 9         super.driving();
10         System.out.println("第二步：我要叫车了...");
11     }
12 }

 

具体装饰(Wait)角色

 1 public class Wait extends Work {
 2 
 3     public Wait(Taxi taxi) {
 4         super(taxi);
 5     }
 6 
 7     @Override
 8     public void driving() {
 9         super.driving();
10         System.out.println("第三步：正在等待中...");
11     }
12 }

 

具体装饰(ByBus)角色

 1 public class ByBus extends Work {
 2 
 3     public ByBus(Taxi taxi) {
 4         super(taxi);
 5     }
 6 
 7     @Override
 8     public void driving() {
 9         super.driving();
10         System.out.println("第四步：坐上车了...");
11     }
12 }

 

具体装饰(PayMoney)角色

 

 1 public class PayMoney extends Work {
 2 
 3     public PayMoney(Taxi taxi) {
 4         super(taxi);
 5     }
 6 
 7     @Override
 8     public void driving() {
 9         super.driving();
10         System.out.println("第五步：到家付钱了...");
11     }
12 }

 

 

工厂(TaxiFactory)

1 public class TaxiFactory {
2 
3     /**出租车工厂控制出租车工作顺序*/
4     public static Taxi geTaxi(){
5         //执行顺序 Car.driving() -> CallTaxi.driving()-> Wait.driving()-> 
　　　　　 //ByBus.driving()-> PayMoney.driving()
6         return new PayMoney(new ByBus(new Wait(new CallTaxi(new Car()))));
7     }
8 
9 }

 

测试类(TestMain)

1 public class TestMain {
2 
3 
4     public static void main(String[] args) {
5         Taxi taxi = TaxiFactory.geTaxi();
6         taxi.driving();
7     }
8 
9 }

 

 

测试类执行结果

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

 

转载于:https://www.cnblogs.com/IT-study/p/11192201.html