如何在Java中实现子类调用blah后自动执行父类foo方法？

针对需求——调用父类A或子类B的blah()方法后，自动执行A的foo()方法，这里提供几种Java的实现方案，对应你用Python装饰器达成的效果：

方案1：模板方法模式（推荐，无框架依赖） #

这是最可靠的实现方式，通过拆分方法逻辑强制触发foo()，无需子类额外配合。

核心思路：父类A对外暴露blah()方法，内部先调用子类自定义的业务逻辑方法（如doBlah()），再固定执行foo()；子类仅需重写doBlah()实现自己的业务，不用关心foo()的触发逻辑。

class A {
    // 对外的公共方法，子类不重写这个
    public void blah() {
        doBlah(); // 调用子类的自定义逻辑
        foo();    // 固定执行foo
    }

    // 子类需要重写的自定义业务方法
    protected void doBlah() {
        // 默认空实现
    }

    void foo() {
        System.out.println("foo called");
    }
}

class B extends A {
    @Override
    protected void doBlah() {
        System.out.println("blah called");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        new B().blah();
        // 输出：
        // blah called
        // foo called
    }
}

方案2：依赖子类调用super.blah()（不推荐，可靠性低） #

让父类的blah()方法最后执行foo()，要求子类重写blah()时必须手动调用super.blah()，否则foo()不会触发。

class A {
    protected void blah() {
        foo(); // 父类blah最后执行foo
    }

    void foo() {
        System.out.println("foo called");
    }
}

class B extends A {
    @Override
    protected void blah() {
        System.out.println("blah called");
        super.blah(); // 必须添加这句，否则foo不执行
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        new B().blah();
        // 输出：
        // blah called
        // foo called
    }
}

缺点：完全依赖子类遵守编码约定，一旦子类忘记调用super.blah()，foo()就不会执行，风险较高。

方案3：AOP面向切面编程（适合多类复用场景） #

如果需要给多个类的方法添加类似的后置逻辑，可以用AOP实现，类似Python装饰器的切面思想。下面以AspectJ为例：

1. 定义切面类，拦截A及其子类的blah()方法执行后调用foo()：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class BlahAfterAspect {
    // 匹配A及其子类的blah方法
    @AfterReturning("execution(* A+.blah(..))")
    public void afterBlahExecution(JoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        if (target instanceof A) {
            ((A) target).foo();
        }
    }
}

2. 配置AOP生效（如通过XML或注解配置），之后调用new B().blah()时，会自动触发foo()执行。

优点：无需修改原有类的代码结构，解耦逻辑；缺点：需要引入AOP框架（如Spring AOP、AspectJ），增加项目复杂度。

内容的提问来源于stack exchange，提问作者krasnaya