如何让可重写的Java方法无限重复且不触发StackOverflowException？

嘿，我太懂你这种踩坑的感觉了——你写的这段代码直接触发了无限递归，栈帧堆得太多自然就炸了！咱们来拆解下问题根源，再给你几个靠谱的解决方案：

问题出在哪？ #

你看，父类的loop()方法是直接递归调用自己：

public void loop() { loop(); }

子类重写后调用super.loop()，这就相当于子类每次执行loop()，都会触发父类的递归逻辑。而递归每调用一次就会在JVM的栈上创建一个新的方法栈帧，Java的栈容量是有限的，很快就会把栈空间耗尽，抛出StackOverflowException。

靠谱的解决方案 #

方案1：用迭代替代递归（推荐） #

把父类的递归逻辑改成迭代循环，同时用模板方法模式把具体业务逻辑交给子类实现，这样既避免了栈溢出，又保留了方法可重写的特性：

父类代码：

public abstract class BaseLoop {
    // 加个开关控制循环启停，避免真的无限卡死
    private volatile boolean isRunning = true;

    public void loop() {
        // 迭代循环，不会不断创建栈帧
        while (isRunning) {
            // 让子类实现具体的循环逻辑
            executeLoopLogic();
        }
    }

    // 子类重写这个方法，实现自己的业务逻辑
    protected abstract void executeLoopLogic();

    // 提供停止循环的方法
    public void stopLoop() {
        isRunning = false;
    }
}

子类代码：

public class CustomLoop extends BaseLoop {
    @Override
    protected void executeLoopLogic() {
        // 这里写你原来的"some stuff"
        System.out.println("执行自定义循环逻辑");
        // 可以加短暂休眠，避免CPU占用过高
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

方案2：用线程异步执行循环 #

如果你的场景需要循环在后台运行，可以把循环逻辑放到单独的线程里，同样用迭代避免递归：

父类代码：

public class BaseLoop {
    private Thread loopThread;
    private volatile boolean isRunning = false;

    public void startLoop() {
        if (!isRunning) {
            isRunning = true;
            loopThread = new Thread(this::runLoop);
            loopThread.start();
        }
    }

    protected void runLoop() {
        while (isRunning) {
            doLoop();
        }
    }

    // 子类重写这个方法
    public void doLoop() {
        // 父类默认空实现，或者写通用逻辑
    }

    public void stopLoop() {
        isRunning = false;
        if (loopThread != null) {
            loopThread.interrupt();
        }
    }
}

子类代码：

public class CustomLoop extends BaseLoop {
    @Override
    public void doLoop() {
        // 你的业务逻辑
        System.out.println("后台循环执行中...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

关键提醒 #

不管用哪种方案，绝对要避免无终止条件的递归——Java的调用栈深度一般在几千到几万级别（取决于JVM参数），无限递归肯定会触发栈溢出。迭代循环只会复用同一个栈帧，不会有这个问题。

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