Java中的继承和增量运算符 package.com公司； 公共A类{ 公共内部a（内部b，内部c）{ return--b； } 公共静态void main（字符串参数[]）{ A=新的B（）； 系统输出打印项次（a.a（10001000））； } } B类扩展了A类{ 公共内部a（内部b，内部c）{ if（b0？a（super.a（b，c），c）：a（b，super.a（c，b））； } }

我编译程序：

二,

我以为输出是-999，1000

我要做的第一件事就是找到主要的方法

A=新的B（）

因此，创建了类型为B的变量a

系统输出打印项次（a.a（10001000））

a.a（10001000）调用类B中的方法public int a（在类B中不是a，因为变量a是类型B）

由于b*c（10001000）不满足if语句中的条件，因此执行return语句中的if子句

既然b>0

a（super.a（b，c），c）被称为

超级关键字的使用意味着它在类A中被称为父构造函数，并返回--b，即1000-1=999，在类b中的原始方法A中返回C，等于1000

所以它变成了

a（9991000）

这将一直持续到B<0，此时它将调用a（B，super.a（c，B），直到c==0，最后返回2

---

但是，有没有更好的方法来分析这些问题（假设您没有访问编译器的权限）？

理解更多的是++和继承的副作用

简化：

package com.company;
public class A {
    public int a(int b, int c) {
        return --b;
    }

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

    }
}

class B extends A {
    public int a(int b, int c) {
        if (b <= 0 && c == 0) {
            return ++b * ++c * ++b * c++;
        }
        return b > 0 ? a(super.a(b,c),c) : a(b, super.a(c,b));
    }
}

public int a（int b，int c）{
如果（b=0
}
返回b>0？a（b-1，c）：a（c-1，b）；
}

---

这看起来一点都不难。

你是在问是否有更有效的方法来阅读代码吗？你分析正确，我不明白你的问题。你必须在心里编译它如果你没有访问编译器的权限，没有其他选择：）我建议您避免使用诸如“代码> +b*+c*++b*C++＋代码>的表达式。是的，它是正确的，但支持它在第一眼是不清楚的。必须分析它。您不介意，即：<代码> BC++；C++，d++；int tMP= b*c*d*c；C++；返回tMP；比一行表达式更清楚。此外，您不能预测哪个<代码>。*运算符将首先计算，因为它不在规范中。

public int a(int b, int c) {
    if (b <= 0 && c == 0) {
        //return ++b * ++c * ++b * c++;
        //return ++b * 1 * ++b * 1;
        return (b+1) * (b+2);
        return 2; // When before recursion the original b >= 0
    }
    return b > 0 ? a(b-1, c) : a(c-1, b);
}