深入理解Java Decorator模式：如何处理内部方法与继承的替代方案

// 原始接口
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;
    }
}

// 装饰器实现 (存在问题)
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();
    }
}

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

// 抽象基类，定义了行为和内部调用逻辑
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