Java：主类中的递归调用子类方法，而不是它自己的方法

例如：

class MainClass {
    public doIt() {
        ...
        else doIt();
    }
}

class SubClass extends MainClass {
    @Override
    public doIt() {
        super.doIt();
        ...
    }
}

现在的问题是：

• 我调用SubClass.doIt（）
• 调用MainClass.doIt（）
• MainClass.doIt（）进行递归调用doIt（）
  但是：调用子类.doIt（）而不是MainClass.doIt（）

这是非常奇怪的行为和问题的编程！我试图用这个.doIt（）调用递归，但没有用。 有人有主意吗

---

非常感谢您的回答，这个问题已经解决了。

这是假定的行为，通过不设置方法

final

，这意味着它可以被

覆盖

n，因此您必须始终考虑到有人可以这样做。对该方法的调用永远不能保证在该级别对该方法进行调用

但是，您可以通过使用（

protected

）

final

方法优雅地解决此问题：

class MainClass {

    protected final void innerDoIt () { //final: so no @Override
        ...
        else innerDoIt();
    }

    public void doIt() {
        innerDoIt();
    }

}

然后：

class SubClass extends MainClass {

    @Override
    public doIt() {
        super.doIt();
        ...
    }
}

final

确保该方法不能被重写。所以在那一刻，你有一个契约（保证）

innerDoIt

方法确实是你认为的

innerDoIt

方法

因此，如果您不希望调用方被覆盖，只需将其对冲到另一个

final

方法中即可。通过将其设置为受保护的

，
子类也可以调用该方法

public class Main {

    public static void main(String[] args) {
        B b = new B();
        b.doIt();
        System.out.println();
        A a = new B();
        a.doIt();
    }


    public static class A{
        boolean check=false;
        public void doIt(){
            System.out.println("A start");
            if(check){

            }
            else{
                check = true;
                doIt();
            }
            System.out.println("A end");
        }
    }
    public static class B extends A{
        @Override
        public void doIt() {
            System.out.println("B start");
            super.doIt();
            System.out.println("B end");
        }
    }
}

在本例中，
b
和
a
都是类
b
的实例，因此正如您可能预期的那样，a.doIt（）和b.doIt（）将输出相同的结果

B start
A start
B start
A start
A end
B end
A end
B end

B start
A start
B start
A start
A end
B end
A end
B end

调用
doIt（）
时，您隐式调用的是
this.doIt（）
，而
this
是类
B
的实例。如果不分离
doIt（）
（请参阅CommuSoft的答案）
的内容，就没有语法可以做你想做的事情。这对你来说是多态性。“这是非常奇怪的行为”不太奇怪，
else doIt（）
与
else this.doIt（）
相同，但是
this
引用当前实例，这要感谢动态绑定（多态机制）调用最接近当前类型的
this
类的方法中的代码。因为最接近包含
doIt
的
子类的
类是
子类
本身，所以调用此代码。这是假定的行为。好吧，我不知道，我所有的东西都运行到现在是一个奇迹：p-非常感谢