java设计模式之装饰者模式

一、定义

---

装饰（decorate）模式又称为包装（Wrapper）模式，顾名思义，装饰模式就是对XXX进行包装，使其功能，职责更加完善；说白了就是给对象增加新的功能，是继承关系的一个替代方案。

二、为什么要使用Decorator模式？

---

我们通常来使用继承来实现功能的扩展，如果这些需要扩展的功能很繁多，那么势必会增加系统的复杂性，使程序显得十分的“臃肿”，耦合度很高，同时，使用继承实现功能的扩展，我们必须可预见这些扩展功能，这些功能是编译时就确定的，是静态的。

思想：为一个对象已有的子类添加一些额外的职责。

三、继承方式实现功能的扩展

---

1、简单案例

代码实例：

抽象接口

public interface AbstractCar { public abstract void move(); }

基础实现

public class CarImpl implements AbstractCar{ @Override public void move() { System.out.println("car is driving on the highway"); } }

功能扩展(飞行)

public class FlyCar extends CarImpl { public void fly(){ System.out.println("car is driving in the air"); } @Override public void move() { super.move(); fly(); } }

功能扩展(水行)

public class FlyAndSwimCar extends FlyCar { public void swim(){ System.out.println("car is driving in the water"); } @Override public void move() { super.move(); swim(); } }

测试类

public class Tester { public static void main(String[] args) { AbstractCar car1 = new CarImpl(); car1.move(); System.out.println("------add fly function-----"); AbstractCar car2 = new FlyCar(); car2.move(); System.out.println("------add swiming function-----"); AbstractCar car3 = new FlyAndSwimCar(); car3.move(); } }

输出

car is driving on the highway ------add fly function----- car is driving on the highway car is driving in the air ------add swiming function----- car is driving on the highway car is driving in the air car is driving in the water

四、分析

---

首先我们先来看下类的继承体系

Car |--FlyCar |--FlyAndSwim |--新增其他功能 |--SwimCar |--CarImpl

如果我们有更多的需求，这个继承体系会愈来愈大；这时，我们就可以使用装饰者模式。

五、装饰（Decorate）模式

---

1、简单案例1

代码实例

被装饰者

/** * 抽象汽车类，被装饰者 * @author Administrator * */ public interface Car { public abstract void move(); }

装饰者

public abstract class CarDecorator implements Car { private Car car; public CarDecorator(Car car) { this.car = car; } @Override public void move() { this.car.move(); } }

被装饰者初始装饰

public class CarImpl implements Car { /** * 被装饰者初始状态有些自己的装饰 */ @Override public void move() { System.out.println("car is moving on the highway"); } }

水行装饰

public class SwimingCar extends CarDecorator { public SwimingCar(Car car) { super(car); } public void DrivingInWater(){ System.out.println("car is driving in the water"); } @Override public void move() { super.move(); DrivingInWater(); } }

飞行装饰

public class FlyCar extends CarDecorator { public FlyCar(Car car) { super(car); } public void DrivingInAir(){ System.out.println("car is driving in the air"); } @Override public void move() { super.move(); DrivingInAir(); } }

测试类

public static void main(String[] args) { Car car = new CarImpl(); car.move(); System.out.println("---------------"); CarDecorator fly = new FlyCar(car); fly.move(); System.out.println("---------------"); CarDecorator swiming = new SwimingCar(car); swiming.move(); System.out.println("---------------"); CarDecorator flyAndSwim = new FlyCar(swiming); flyAndSwim.move(); } }

我们再来看下他的继承体系

Car |--CarDecorator |--FlyCar |--SwimingCar |--其他装饰 、 、 、 |--CarImpl

由此可知、使用装饰模式他的继承体系不像单纯的使用继承那样庞大。

1、简单案例2

代码实例

被装饰者

/** * 定义被装饰者 * * @author Administrator * */ public abstract class Pancake { protected String name; public String getName() { return name; } public abstract double getPrice(); }

装饰者

/** * 定义装饰者 * * @author Administrator * */ public abstract class PancakeDecorate extends Pancake { private Pancake pancake; public PancakeDecorate(Pancake pancake) { this.pancake = pancake; } @Override public String getName() { return this.pancake.getName(); } @Override public double getPrice() { return this.pancake.getPrice(); } }

初始化装饰

public class PancakeInit extends Pancake { public PancakeInit(){ name = "煎饼"; } @Override public double getPrice() { return 8; } }

生菜装饰

public class LettuceDecorate extends PancakeDecorate { public LettuceDecorate(Pancake pancake) { super(pancake); } @Override public String getName() { return super.getName()+" 加生菜"; } @Override public double getPrice() { return super.getPrice()+1; } }

鸡蛋装饰

public class EggDecorate extends PancakeDecorate { public EggDecorate(Pancake pancake) { super(pancake); } @Override public String getName() { return super.getName()+"加鸡蛋"; } @Override public double getPrice() { return super.getPrice()+2; } }

火腿装饰

public class HamDecorate extends PancakeDecorate { public HamDecorate(Pancake pancake) { super(pancake); } @Override public String getName() { return super.getName()+" 加火腿"; } @Override public double getPrice() { return super.getPrice()+2; } }

测试类

public class Tester { public static void main(String[] args) { // 基本的煎饼 Pancake pancake = new PancakeInit(); System.out.println(pancake.getName() + " 价格：" + pancake.getPrice()); // 只加生菜 PancakeDecorate pd = new LettuceDecorate(pancake); System.out.println(pd.getName() + " 价格：" + pd.getPrice()); // 只加火腿 pd = new HamDecorate(pancake); System.out.println(pd.getName() + " 价格：" + pd.getPrice()); // 加鸡蛋，加火腿 pd = new HamDecorate(new LettuceDecorate(pancake)); System.out.println(pd.getName() + " 价格：" + pd.getPrice()); } }

输出

煎饼 价格：8.0 煎饼 加生菜 价格：9.0 煎饼 加火腿 价格：10.0 煎饼 加生菜 加火腿 价格：11.0

六、总结

---

个人理解：装饰者模式的设计对扩展开放、对修改关闭，体现在如果我想扩展被装饰者的职责，无须修改装饰者抽象类，只需要继承装饰者抽象类，实现额外的装饰或者职责只需要对被装饰者进行包装即可。

如果你细心的话上面示例的调用类似于我们读取文件时的调用：

FileReader fr = new FileReader("a.txt"); BufferedReader br = new BufferedReader(fr);

实际上Java 的I/O API就是使用装饰模式实现的,I/O变种很多,如果都采取继承方法,将会产生很多子类,显然相当繁琐.