如何在装饰器模式中处理内部方法调用：理解与替代方案

// 接口定义
public interface Flag {
    int wave();
    int calculateWind();
}

// 具体实现类
public class FlagImpl implements Flag {
    @Override
    public int wave() {
        System.out.println("FlagImpl: Waving.");
        return calculateWind(); // 内部调用 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: This is decorated wave.");
        return flag.wave(); // 委托给被装饰对象的 wave 方法
    }

    @Override
    public int calculateWind() {
        // 注意：原始问题中的这个方法是无限递归的，这里假设它意图是装饰 calculateWind
        System.out.println("DecoratedFlag: This is ALSO decorated calculateWind.");
        // 正确的委托应该是 return flag.calculateWind();
        // 但如果目标是修改 FlagImpl 内部的 calculateWind 调用，这行代码不会被触发
        return flag.calculateWind() + 300; // 示例：在委托基础上增加值
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Flag flag = new DecoratedFlag(new FlagImpl());
        System.out.println("Result of wave(): " + flag.wave());
        // 预期输出可能与实际不符
    }
}

// 1. 定义接口 (Interface)
public interface Flag {
    int wave();
    int calculateWind();
}

// 2. 抽象基类 (Abstract Base Class)：包含默认实现和内部方法调用
public abstract class FlagImplementation implements Flag {
    @Override
    public int calculateWind() {
        System.out.println("FlagImplementation: Calculating wind (default 8).");
        return 8;
    }

    @Override
    public int wave() {
        System.out.println("FlagImplementation: Waving, calling calculateWind().");
        // 这里的 calculateWind() 调用是关键：它会根据实际对象类型进行多态调用
        return calculateWind(); // 如果子类重写了 calculateWind，这里将调用子类的版本
    }
}

// 3. 装饰器-like 子类 (Concrete Subclass)：通过继承修改行为
// 注意：虽然它实现了类似装饰器的功能，但其实现机制是继承而非组合
public class DecoratedFlagByInheritance extends FlagImplementation {
    @Override
    public int wave() {
        System.out.println("DecoratedFlagByInheritance: Waving (adding 100 to base wave).");
        // 调用父类的 wave 方法。父类的 wave 内部会多态调用本类（DecoratedFlagByInheritance）的 calculateWind()
        return super.wave() + 100;
    }

    @Override
    public int calculateWind() {
        System.out.println("DecoratedFlagByInheritance: Calculating wind (adding 300 to base wind).");
        // 调用父类的 calculateWind 方法，获取其基本值
        return super.calculateWind() + 300;
    }
}

// 4. 使用示例
public class MainInheritanceExample {
    public static void main(String[] args) {
        System.out.println("--- Using DecoratedFlagByInheritance (Inheritance Approach) ---");
        // 创建子类实例
        Flag decoratedFlag = new DecoratedFlagByInheritance();

        System.out.println("\nCalling calculateWind() directly on DecoratedFlagByInheritance:");
        System.out.println("Result: " + decoratedFlag.calculateWind()); // 期望输出: 308

        System.out.println("\nCalling wave() on DecoratedFlagByInheritance:");
        System.out.println("Result: " + decoratedFlag.wave()); // 期望输出: 408
    }
}

--- Using DecoratedFlagByInheritance (Inheritance Approach) ---

Calling calculateWind() directly on DecoratedFlagByInheritance:
DecoratedFlagByInheritance: Calculating wind (adding 300 to base wind).
FlagImplementation: Calculating wind (default 8).
Result: 308

Calling wave() on DecoratedFlagByInheritance:
DecoratedFlagByInheritance: Waving (adding 100 to base wave).
FlagImplementation: Waving, calling calculateWind().
DecoratedFlagByInheritance: Calculating wind (adding 300 to base wind).
FlagImplementation: Calculating wind (default 8).
Result: 408