设计模式(二) 打车装饰模式
设计模式(二) 打车装饰模式
装饰模式
装饰模式又叫包装模式。装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
装饰模式的类图
在装饰模式中的角色有：
● 抽象构件(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 第五步：到家付钱了...