class A { double f (double x, double y) { return x + y; } static int g(int n) { return n * n; } } class B extends A { double f(double x, double y) { double m = super.f(x, y); return m + x * y; } static int g(int n) { int m = A.g(n); return m + n; } } public class E { public static void main(String[] args) { B b = new B(); System.out.println(b.f(6.0,12.0)); System.out.println(b.g(8)); A a = new B(); System.out.println(a.f(6.0,12.0)); System.out.println(a.g(8)); } }运行

这段代码的输出结果是：

78.0
64
78.0
64

首先，定义了一个类 `A`，其中有一个非静态的方法 `f` 和一个静态的方法 `g`。然后，定义了一个类 `B`，继承自 `A`，并且重写了方法 `f` 和方法 `g`。

在 `B` 中的方法 `f` 中，先调用了 `super.f(x, y)`，即调用父类的 `f` 方法，然后将结果保存在变量 `m` 中，最后返回 `m + x * y` 的值。

在 `B` 中的方法 `g` 中，先调用了 `A.g(n)`，即调用父类的静态方法 `g`，然后将结果保存在变量 `m` 中，最后返回 `m + n` 的值。

在 `main` 方法中，首先创建了一个 `B` 类对象 `b`，然后分别调用了 `b.f(6.0,12.0)` 和 `b.g(8)` 方法，并将结果输出。

接着，创建了一个 `A` 类对象 `a`，但是通过 `new B()` 的方式创建，然后同样分别调用了 `a.f(6.0,12.0)` 和 `a.g(8)` 方法，并将结果输出。需要注意的是，虽然 `a` 的实际类型是 `B`，但是调用的是 `A` 类的方法，因此调用的是 `B` 类重写之前的 `f` 方法和 `A` 类的静态方法 `g`。但是，由于 `B` 类并没有重写 `f` 方法，因此调用的其实还是 `B` 类中的 `f` 方法。最终输出的结果与调用 `b.f` 和 `b.g` 方法时的结果相同。

相关问题

注释以下代码class A { double f (double x, double y) { return x + y; } static int g(int n) { return n * n; } } class B extends A { double f(double x, double y) { double m = super.f(x, y); return m + x * y; } static int g(int n) { int m = A.g(n); return m + n; } } public class a { public static void main(String[] args) { B b = new B(); System.out.println(b.f(6.0,12.0)); System.out.println(b.g(8)); A a = new B(); System.out.println(a.f(6.0,12.0)); System.out.println(a.g(8)); } }

这段代码定义了两个类A和B，B是A的子类。A中有一个f方法和一个静态的g方法，B继承了A的f方法并重写了它，同时也重写了静态的g方法。

在主类a中，首先创建了一个B对象b，并调用了它的f方法和g方法，分别输出了b.f(6.0,12.0)和b.g(8)的结果。

然后又创建了一个A对象a，并将它指向了一个B对象，再调用a的f方法和g方法，分别输出了a.f(6.0,12.0)和a.g(8)的结果。因为a是A类型的引用，所以调用的f方法是A中的方法，但因为a指向的对象是B对象，所以实际执行的是B中重写后的f方法。而对于静态方法g，无论是用B对象还是A对象来调用，都只会执行A中的静态方法g。

class A i double f(double x,double y)f return x+y; } static int g(int n) i return n* n; } } class B extends A i double f(double x,double y) i double m = super.f(x,y);return m+x* y; } static int g(int n){ int m = A.g(n);return m +n; } }public class E i public static void main(String[ ] args){ Bb = new B(); system.out.print1n(b.f(10.0,8.0));System.out.print1n(b.g( 3)); Aa = new B(); System.out.print1n(a.f(10.0,8.0));System.out.print1n(a.g(3)); } }运行结果

这段代码中有一些错误，我先进行修正：

class A {
    public double f(double x, double y) {
        return x + y;
    }
    
    public static int g(int n) {
        return n * n;
    }
}

class B extends A {
    public double f(double x, double y) {
        double m = super.f(x, y);
        return m + x * y;
    }
    
    public static int g(int n) {
        int m = A.g(n);
        return m + n;
    }
}

public class E {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.f(10.0, 8.0));
        System.out.println(b.g(3));
        
        A a = new B();
        System.out.println(a.f(10.0, 8.0));
        System.out.println(a.g(3));
    }
}

修正后，运行结果为：

108.0
12
108.0
9

解释一下运行结果：

1. `b.f(10.0, 8.0)` 调用的是类 B 中的 `f` 方法，先调用了 A 类中的 `f` 方法求出 `m` 的值，然后返回 `m+x*y`，即 `18+80=108.0`。
2. `b.g(3)` 调用的是类 B 中的 `g` 方法，先调用了 A 类中的 `g` 方法求出 `m` 的值，然后返回 `m+n`，即 `9+3=12`。
3. `a.f(10.0, 8.0)` 调用的是类 B 中的 `f` 方法，因为 `a` 是一个 `A` 类型的变量，但是 `a` 实际上是一个 `B` 类型的对象，所以调用的是 `B` 类中的 `f` 方法。和上面的情况一样，先调用了 A 类中的 `f` 方法求出 `m` 的值，然后返回 `m+x*y`，即 `18+80=108.0`。
4. `a.g(3)` 调用的是类 A 中的 `g` 方法，因为 `g` 是一个静态方法，所以不会根据对象类型来调用方法。直接返回 `n*n`，即 `3*3=9`。