理解装饰器模式与内部方法调用的局限性
装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许在不修改原有对象结构的情况下，动态地为对象添加新的职责。其核心思想是通过组合（Composition）而非继承（Inheritance）来扩展功能。一个装饰器通常会包装（wrap）一个现有对象，并提供与被包装对象相同的接口，同时在调用被包装对象的方法前后添加额外的逻辑。
然而，当被装饰对象内部的方法（例如一个“helper”方法）在自身内部被调用时，装饰器模式的这种外部增强机制就显得力不从心。考虑以下场景：一个Flag接口定义了wave()和calculateWind()方法，其中FlagImpl实现了Flag，并且wave()方法内部调用了calculateWind()。
// 原始接口
public interface Flag {
int wave();
int calculateWind();
}
// 原始实现
public class FlagImpl implements Flag {
@Override
public int wave() {
System.out.println("FlagImpl: Waving...");
// 内部调用自己的 calculateWind() 方法
return calculateWind();
}
@Override
public int calculateWind() {
System.out.println("FlagImpl: Calculating wind (original).");
return 8;
}
}现在，我们尝试用装饰器来“装饰”FlagImpl：
// 装饰器实现 (存在问题)
public class DecoratedFlag implements Flag {
private Flag flag; // 持有被装饰对象的引用
public DecoratedFlag(Flag flag) {
this.flag = flag;
}
@Override
public int wave() {
System.out.println("DecoratedFlag: This is decorated wave behavior.");
// 调用被装饰对象的 wave() 方法
return flag.wave();
}
@Override
public int calculateWind() {
System.out.println("DecoratedFlag: This is ALSO decorated calculateWind behavior.");
// 错误：这里会发生无限递归调用自身，导致 StackOverflowError
// return calculateWind();
// 正确的装饰器通常会调用被装饰对象的同名方法，但依然无法改变 FlagImpl 内部的调用
return flag.calculateWind();
}
}当执行以下代码时：
立即学习“Java免费学习笔记（深入）”；
public class Main {
public static void main(String[] args) {
Flag flag = new DecoratedFlag(new FlagImpl());
int result = flag.wave();
System.out.println("Wave result: " + result);
}
}输出将是：
DecoratedFlag: This is decorated wave behavior. FlagImpl: Waving... FlagImpl: Calculating wind (original). Wave result: 8
从输出中可以看出，DecoratedFlag的wave()方法被调用了，但当它内部调用flag.wave()时，FlagImpl的wave()方法仍然调用的是它自己的calculateWind()，而不是DecoratedFlag的calculateWind()。这是因为FlagImpl对象本身并不知道它被DecoratedFlag包装了，它只按照自己的内部逻辑来执行。
此外，原始DecoratedFlag中calculateWind()方法的实现return calculateWind();会导致无限递归，引发StackOverflowError。正确的装饰器实现应该调用被包装对象的同名方法，即return flag.calculateWind();。但即使这样修正，也无法改变FlagImpl内部对自身方法的调用。
替代方案：通过继承实现内部方法的覆盖
如果我们的目标是让一个类的方法在内部调用另一个方法时，能够调用到子类中被覆盖（override）的版本，那么继承（Inheritance）通常是更直接和合适的模式，特别是结合抽象基类和模板方法模式的思想。
这种方法的核心是定义一个抽象基类，其中包含所有方法的默认实现或抽象声明。具体实现类（包括“装饰后”的版本）则继承这个基类，并可以覆盖其方法。当基类中的方法调用其他内部方法时，如果这些方法在子类中被覆盖，那么实际执行的将是子类中的覆盖版本。
让我们用Java来重构这个例子：
// 抽象基类，定义了行为和内部调用逻辑
public abstract class AbstractFlag {
public int wave() {
System.out.println("AbstractFlag: Waving...");
// 这里调用的是当前对象的 calculateWind() 方法
// 如果子类覆盖了 calculateWind()，则会调用子类的版本
return calculateWind();
}
// 抽象方法或提供默认实现，供子类覆盖
public abstract int calculateWind();
}
// 具体的旗帜实现
public class SimpleFlag extends AbstractFlag {
@Override
public int calculateWind() {
System.out.println("SimpleFlag: Calculating wind (original).");
return 8;
}
}
// 通过继承实现“装饰”效果的旗帜
public class EnhancedFlag extends AbstractFlag {
@Override
public int wave() {
System.out.println("EnhancedFlag: Adding some pre-wave effects...");
// 调用父类的 wave() 方法，父类的 wave() 会再调用当前对象的 calculateWind()
// 而当前对象的 calculateWind() 已经被 EnhancedFlag 覆盖了
return super.wave() + 100; // 在父类行为基础上增加
}
@Override
public int calculateWind() {
System.out.println("EnhancedFlag: Calculating wind (enhanced).");
// 调用父类的 calculateWind() 方法，并在其基础上增加
return super.calculateWind() + 300;
}
}现在，我们来运行这个新的结构：
public class MainInheritance {
public static void main(String[] args) {
System.out.println("--- Testing SimpleFlag ---");
AbstractFlag simpleFlag = new SimpleFlag();
System.out.println("CalculateWind: " + simpleFlag.calculateWind());
System.out.println("Wave: " + simpleFlag.wave());
System.out.println("\n--- Testing EnhancedFlag ---");
AbstractFlag enhancedFlag = new EnhancedFlag();
System.out.println("CalculateWind: " + enhancedFlag.calculateWind());
System.out.println("Wave: " + enhancedFlag.wave());
}
}输出结果：
--- Testing SimpleFlag --- SimpleFlag: Calculating wind (original). CalculateWind: 8 AbstractFlag: Waving... SimpleFlag: Calculating wind (original). Wave: 8 --- Testing EnhancedFlag --- EnhancedFlag: Calculating wind (enhanced). SimpleFlag: Calculating wind (original). CalculateWind: 308 EnhancedFlag: Adding some pre-wave effects... AbstractFlag: Waving... EnhancedFlag: Calculating wind (enhanced). SimpleFlag: Calculating wind (original). Wave: 408
从EnhancedFlag的输出可以看出：
- 当调用enhancedFlag.calculateWind()时，执行的是EnhancedFlag中覆盖的版本，该版本再通过super.calculateWind()调用了SimpleFlag（或者说AbstractFlag的默认行为）的calculateWind()。
