装饰模式
定义
动态地给一个对象添加额外的职责，就增加功能来说，它比生成子类更加灵活。
通用类图
通用类图.png
Component是抽象构建，也就是最原始的不加以装饰的类，ConcreteComponent是实现具体的操作。Decorator是修饰者，它持有一个Component对象引用，利用这个引用添加修饰，而ConcreteDecorator是具体的修饰，修饰相应的功能。
通用代码
// 抽象构建
public abstract class Component {
public abstract void operate();
}
// 实现
public class ConcreteComponent extends Component {
@Override
public void operate() {
// 原始的操作
}
}
// 抽象装饰者
public abstract class Decorator extends Component{
private Component component;
public Decorator(Component component) { // 构造注入
this.component = component;
}
@Override
public void operate() {
this.component.operate();
}
}
// A装饰
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void methodA() {
// 自己需要进行额外操作的方法
}
@Override
public void operate() {
methodA();
super.operate();
}
}
// B装饰
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
public void methodB() {
// 自己需要进行额外操作的方法
}
@Override
public void operate() {
methodB();
super.operate();
}
}
// 客户端调用
public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent(); // 原始构件，不加任何修饰
component = new ConcreteDecoratorA(component); // 给它添加A功能
component = new ConcreteDecoratorB(component); // 再给他添加B功能;
component.operate(); // 处理原始的功能操作，还拥有A、B的功能
}
}
样例展示
假如有这么一个“喜羊羊逃命”游戏：喜羊羊被灰太狼追，喜羊羊最多5条命，灰太狼每咬到喜羊羊一次，喜羊羊就要少一条命。在逃的过程中喜羊羊可以吃到三种苹果，吃“红苹果”可以给喜羊羊加上保护罩，吃“绿苹果”可以加快喜羊羊奔跑速度，吃“黄苹果”可以使喜羊羊趟着水跑。
分析：最开始的喜羊羊平平凡凡，但是吃了苹果便可以获得不同的能力。假如不用装饰模式，为了表示吃了相应苹果获得不同能力的喜羊羊，我们需要继承喜羊羊生成6种超能力喜羊羊子类，可谓是复杂。通过装饰模式，实现三种装饰，每包装一个喜羊羊就获得一种相应的能力，大大降低了类的耦合性。
样例类图
样例类图.png
代码展示
// 抽象的羊
public abstract class Sheep {
public abstract void ability();
}
// 喜羊羊
public class XSheep extends Sheep {
@Override
public void ability() {
System.out.println("能力平平");
}
}
// 抽象苹果，相当于抽象装饰者
public abstract class Apple extends Sheep {
private Sheep sheep;
public Apple(Sheep sheep) {
this.sheep = sheep;
}
// 获得超能力
public abstract void addPower();
@Override
public void ability() {
this.sheep.ability(); // 这句代码别忘了
addPower();
}
}
public class RedApple extends Apple {
public RedApple(Sheep sheep) {
super(sheep);
}
@Override
public void addPower() {
System.out.println("获得保护罩");
}
}
public class GreenApple extends Apple {
public GreenApple(Sheep sheep) {
super(sheep);
}
@Override
public void addPower() {
System.out.println("获得加速能力");
}
}
public class YellowApple extends Apple {
public YellowApple(Sheep sheep) {
super(sheep);
}
@Override
public void addPower() {
System.out.println("获得趟着水跑的能力");
}
}
// 客户端调用
public class Client {
public static void main(String[] args) {
Sheep xi = new XSheep();
xi.ability(); // 平凡的喜羊羊
// 添加超能力
xi = new RedApple(xi); // 获得保护罩
xi = new GreenApple(xi); // 获得加速
xi = new YellowApple(xi); // 趟着水跑
xi.ability();
}
}
本文为《设计模式之禅》读后笔记总结
