装饰器模式（decorator pattern）是一种结构型设计模式，它允许在不改变原有对象结构的情况下，动态地给对象添加新的功能。它通过将对象包装在一个装饰器对象中，从而在运行时增强其行为。然而，当被装饰对象内部的方法调用其自身的其他辅助方法时，一个常见的误解是这些内部调用也会自动经过装饰器。实际上，情况并非如此。
考虑以下Java代码示例，它模拟了一个旗帜（Flag）及其风力计算（calculateWind）和飘扬（wave）的行为：
// 旗帜接口
public interface Flag {
int wave();
int calculateWind();
}
// 旗帜实现类
public class FlagImpl implements Flag {
@Override
public int wave() {
System.out.println("FlagImpl: Waving and calculating wind...");
// 内部调用自身的calculateWind方法
return calculateWind();
}
@Override
public int calculateWind() {
System.out.println("FlagImpl: Calculating wind (default: 8)");
return 8;
}
}
// 装饰器类
public class DecoratedFlag implements Flag {
private Flag flag; // 持有被装饰对象的引用
public DecoratedFlag(Flag flag) {
this.flag = flag;
}
@Override
public int wave() {
System.out.println("DecoratedFlag: Adding decorated wave behavior.");
// 调用被包装对象的wave方法
return flag.wave();
}
@Override
public int calculateWind() {
System.out.println("DecoratedFlag: Adding decorated calculateWind behavior.");
// 调用被包装对象的calculateWind方法
return flag.calculateWind() + 10; // 增加额外风力
}
}
// 示例运行
public class Main {
public static void main(String[] args) {
Flag flag = new DecoratedFlag(new FlagImpl());
int windResult = flag.wave(); // 调用装饰器上的wave方法
System.out.println("Final wave result (wind): " + windResult);
System.out.println("\n--- Directly calling calculateWind ---");
int directWindResult = flag.calculateWind(); // 直接调用装饰器上的calculateWind方法
System.out.println("Direct calculateWind result: " + directWindResult);
}
}运行上述代码，你会观察到以下输出：
DecoratedFlag: Adding decorated wave behavior. FlagImpl: Waving and calculating wind... FlagImpl: Calculating wind (default: 8) Final wave result (wind): 8 --- Directly calling calculateWind --- DecoratedFlag: Adding decorated calculateWind behavior. FlagImpl: Calculating wind (default: 8) Direct calculateWind result: 18
从输出中可以看出，当通过 flag.wave() 调用时，DecoratedFlag 的 wave() 方法被执行了，然后它委托给 FlagImpl 的 wave() 方法。然而，FlagImpl 内部的 wave() 方法调用 calculateWind() 时，执行的是 FlagImpl 自身的 calculateWind() 方法，而不是 DecoratedFlag 中增强过的 calculateWind() 方法。
这个现象的关键在于Java中 this 关键字的作用域和方法调用的解析机制。当 FlagImpl 类的 wave() 方法内部调用 calculateWind() 时，它实际上是调用 this.calculateWind()。这里的 this 指向的是当前的 FlagImpl 实例本身，而不是外部的 DecoratedFlag 实例。
立即学习“Java免费学习笔记（深入）”；
装饰器模式的工作原理是“包装”一个接口。它通过实现相同的接口，并在内部持有一个对被包装对象的引用，从而在方法调用时进行拦截、增强或委托。只有通过装饰器对象（DecoratedFlag 实例）调用的方法（例如 flag.wave() 或 flag.calculateWind()）才会被装饰器所拦截和处理。而一旦控制权传递到被包装对象内部，其内部方法之间的调用将完全按照其自身的逻辑进行，与外部的装饰器无关。
简而言之，装饰器只作用于其公共接口暴露的方法调用，它无法“渗透”到被装饰对象内部的方法调用链中。
如果你的目标是修改一个类内部方法（包括辅助方法）的行为，并且这些修改需要影响到该类内部的其他方法调用，那么装饰器模式可能不是最直接或最合适的解决方案。在这种情况下，继承（或结合模板方法模式）通常是更好的选择。
通过继承，你可以创建一个抽象基类来定义核心行为，并允许子类重写或扩展这些行为，包括那些作为辅助方法被内部调用的方法。
以下是使用继承来解决上述问题的示例：
// 抽象基类，定义旗帜的基本行为
public abstract class AbstractFlag implements Flag { // 实现了Flag接口
@Override
public int calculateWind() {
System.out.println("AbstractFlag: Calculating base wind (default: 8)");
return 8;
}
@Override
public int wave() {
System.out.println("AbstractFlag: Waving based on calculated wind...");
// 内部调用自身的calculateWind方法，但这个calculateWind可以被子类重写
return calculateWind();
}
}
// 具体实现类，继承并重写行为
public class EnhancedFlag extends AbstractFlag {
@Override
public int calculateWind() {
System.out.println("EnhancedFlag: Calculating enhanced wind (base + 10)");
// 调用父类的calculateWind方法，并在此基础上增加额外逻辑
return super.calculateWind() + 10;
}
@Override
public int wave() {
System.out.println("EnhancedFlag: Waving with enhanced logic.");
// 调用父类的wave方法，它会调用当前实例（即EnhancedFlag）的calculateWind
return super.wave();
}
}
// 示例运行
public class MainInheritance {
public static void main(String[] args) {
Flag enhancedFlag = new EnhancedFlag(); // 直接创建增强后的对象
int windResult = enhancedFlag.wave();
System.out.println("Final wave result (wind): " + windResult);
System.out.println("\n--- Directly calling calculateWind ---");
int directWindResult = enhancedFlag.calculateWind();
System.out.println("Direct calculateWind result: " + directWindResult);
}
}运行 MainInheritance 的输出如下：
EnhancedFlag: Waving with enhanced logic. AbstractFlag: Waving based on calculated wind... EnhancedFlag: Calculating enhanced wind (base + 10) AbstractFlag: Calculating base wind (default: 8) Final wave result (wind): 18 --- Directly calling calculateWind --- EnhancedFlag: Calculating enhanced wind (base + 10) AbstractFlag: Calculating base wind (default: 8) Direct calculateWind result: 18
在这个继承的例子中，EnhancedFlag 重写了 calculateWind() 方法。当 EnhancedFlag 的 wave() 方法（或者通过 super.wave() 调用的 AbstractFlag 的 wave() 方法）内部调用 calculateWind() 时，由于多态性，实际执行的是 EnhancedFlag 中重写过的 calculateWind() 方法。通过 super.calculateWind()，我们还能在子类中调用父类的原始实现，并在其基础上添加或修改行为。
理解这两种模式的适用场景至关重要：
装饰器模式（Decorator Pattern）：
继承（Inheritance）：
在最初的问题中，如果目标是让 FlagImpl 内部的 wave() 方法调用一个“被装饰过”的 calculateWind()，那么这实际上意味着你希望修改 FlagImpl 自身的行为。在这种情况下，继承（如上述 AbstractFlag 和 EnhancedFlag 的例子）是更直接和符合逻辑的设计选择，因为它允许子类覆盖或增强父类的内部行为。
总之，装饰器模式是动态添加行为的强大工具，但它有其作用边界。当涉及到修改类内部方法之间的交互逻辑时，继承通常能提供更清晰、更直接的解决方案。
以上就是Java装饰器模式与内部方法调用：何时考虑继承的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
238
